add python3 suppport based on 2to3 script
This commit is contained in:
Stefan Klug
parent
caef0e85d0
commit
4f91a30fec
68 changed files with 597 additions and 576 deletions
|
|
@ -50,12 +50,12 @@ class UnicodeBuffer:
|
|||
self.buffer = []
|
||||
def write(self, s):
|
||||
if s == None: return
|
||||
if isinstance(s, unicode):
|
||||
if isinstance(s, str):
|
||||
self.buffer.append(s)
|
||||
elif isinstance(s, str):
|
||||
self.buffer.append(s.decode('utf-8'))
|
||||
else:
|
||||
self.buffer.append(unicode(s))
|
||||
self.buffer.append(str(s))
|
||||
def getValue(self):
|
||||
return u''.join(self.buffer)
|
||||
return ''.join(self.buffer)
|
||||
# ------------------------------------------------------------------------------
|
||||
|
|
|
|||
|
|
@ -109,18 +109,18 @@ class CsvParser:
|
|||
def convertValue(self, value, basicType):
|
||||
'''Converts the atomic p_value which is a string into some other atomic
|
||||
Python type specified in p_basicType (int, float, ...).'''
|
||||
if (basicType != str) and (basicType != unicode):
|
||||
if (basicType != str) and (basicType != str):
|
||||
try:
|
||||
exec 'res = %s' % str(value)
|
||||
except SyntaxError, se:
|
||||
exec('res = %s' % str(value))
|
||||
except SyntaxError as se:
|
||||
res = None
|
||||
else:
|
||||
try:
|
||||
exec 'res = """%s"""' % str(value)
|
||||
except SyntaxError, se:
|
||||
exec('res = """%s"""' % str(value))
|
||||
except SyntaxError as se:
|
||||
try:
|
||||
exec "res = '''%s'''" % str(value)
|
||||
except SyntaxError, se:
|
||||
exec("res = '''%s'''" % str(value))
|
||||
except SyntaxError as se:
|
||||
res = None
|
||||
return res
|
||||
|
||||
|
|
@ -183,7 +183,7 @@ class CsvParser:
|
|||
self.res.append(lineObject)
|
||||
f.close()
|
||||
# The second pass resolves the p_references if any
|
||||
for attrName, refInfo in self.references.iteritems():
|
||||
for attrName, refInfo in self.references.items():
|
||||
if attrName in self.attributes:
|
||||
# Replace ID with real object from p_references
|
||||
for obj in self.res:
|
||||
|
|
@ -228,7 +228,7 @@ class CsvMarshaller:
|
|||
|
||||
def marshallValue(self, field, value):
|
||||
'''Produces a version of p_value that can be dumped in a CSV file.'''
|
||||
if isinstance(value, basestring):
|
||||
if isinstance(value, str):
|
||||
# Format the string as a one-line CSV-ready value
|
||||
res = self.marshallString(value)
|
||||
elif type(value) in sequenceTypes:
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
# ------------------------------------------------------------------------------
|
||||
import os, re, httplib, sys, stat, urlparse, time, socket, xml.sax
|
||||
import urllib
|
||||
import os, re, http.client, sys, stat, urllib.parse, time, socket, xml.sax
|
||||
from urllib.parse import quote
|
||||
from StringIO import StringIO
|
||||
from mimetypes import guess_type
|
||||
from base64 import encodestring
|
||||
|
|
@ -19,12 +19,12 @@ class FormDataEncoder:
|
|||
|
||||
def marshalValue(self, name, value):
|
||||
if isinstance(value, basestring):
|
||||
return '%s=%s' % (name, urllib.quote(str(value)))
|
||||
return '%s=%s' % (name, quote(str(value)))
|
||||
elif isinstance(value, float):
|
||||
return '%s:float=%s' % (name, value)
|
||||
elif isinstance(value, int):
|
||||
return '%s:int=%s' % (name, value)
|
||||
elif isinstance(value, long):
|
||||
elif isinstance(value, int):
|
||||
res = '%s:long=%s' % (name, value)
|
||||
if res[-1] == 'L':
|
||||
res = res[:-1]
|
||||
|
|
@ -101,8 +101,8 @@ class HttpResponse:
|
|||
redirect the user to if self.code is 302, or will unmarshall XML
|
||||
data into Python objects.'''
|
||||
if self.code == 302:
|
||||
return urlparse.urlparse(self.headers['location'])[2]
|
||||
elif self.headers.has_key('content-type'):
|
||||
return urllib.parse.urlparse(self.headers['location'])[2]
|
||||
elif 'content-type' in self.headers:
|
||||
contentType = self.extractContentType(self.headers['content-type'])
|
||||
for xmlHeader in self.xmlHeaders:
|
||||
if contentType.startswith(xmlHeader):
|
||||
|
|
@ -116,7 +116,7 @@ class HttpResponse:
|
|||
raise ResourceError('Distant server exception: ' \
|
||||
'%s' % res)
|
||||
return res
|
||||
except xml.sax.SAXParseException, se:
|
||||
except xml.sax.SAXParseException as se:
|
||||
raise ResourceError('Invalid XML response (%s)'%str(se))
|
||||
|
||||
# ------------------------------------------------------------------------------
|
||||
|
|
@ -158,7 +158,7 @@ class Resource:
|
|||
def updateHeaders(self, headers):
|
||||
# Add credentials if present
|
||||
if not (self.username and self.password): return
|
||||
if headers.has_key('Authorization'): return
|
||||
if 'Authorization' in headers: return
|
||||
credentials = '%s:%s' % (self.username, self.password)
|
||||
credentials = credentials.replace('\012', '')
|
||||
headers['Authorization'] = "Basic %s" % encodestring(credentials)
|
||||
|
|
@ -170,19 +170,19 @@ class Resource:
|
|||
|
||||
def send(self, method, uri, body=None, headers={}, bodyType=None):
|
||||
'''Sends a HTTP request with p_method, for p_uri.'''
|
||||
conn = httplib.HTTPConnection(self.host, self.port)
|
||||
conn = http.client.HTTPConnection(self.host, self.port)
|
||||
try:
|
||||
conn.connect()
|
||||
except socket.gaierror, sge:
|
||||
except socket.gaierror as sge:
|
||||
raise ResourceError('Check your Internet connection (%s)'% str(sge))
|
||||
except socket.error, se:
|
||||
except socket.error as se:
|
||||
raise ResourceError('Connection error (%s)' % str(se))
|
||||
# Tell what kind of HTTP request it will be.
|
||||
conn.putrequest(method, uri, skip_host=True)
|
||||
# Add HTTP headers
|
||||
self.updateHeaders(headers)
|
||||
if self.headers: headers.update(self.headers)
|
||||
for n, v in headers.items(): conn.putheader(n, v)
|
||||
for n, v in list(headers.items()): conn.putheader(n, v)
|
||||
conn.endheaders()
|
||||
# Add HTTP body
|
||||
if body:
|
||||
|
|
|
|||
|
|
@ -250,7 +250,7 @@ class HtmlDiff:
|
|||
deleteStyle = 'color: red; text-decoration: line-through; cursor: help'
|
||||
|
||||
def __init__(self, old, new,
|
||||
insertMsg=u'Inserted text', deleteMsg=u'Deleted text',
|
||||
insertMsg='Inserted text', deleteMsg='Deleted text',
|
||||
insertCss=None, deleteCss=None, insertName='insert',
|
||||
deleteName='delete', diffRatio=0.7):
|
||||
# p_old and p_new are strings containing chunks of HTML. If they are not
|
||||
|
|
@ -306,24 +306,24 @@ class HtmlDiff:
|
|||
else: tag = 'span'
|
||||
# What message will it show in its 'title' attribute?
|
||||
if not msg:
|
||||
exec 'msg = self.%sMsg' % type
|
||||
exec('msg = self.%sMsg' % type)
|
||||
# What CSS class (or, if none, tag-specific style) will be used ?
|
||||
exec 'cssClass = self.%sCss' % type
|
||||
exec('cssClass = self.%sCss' % type)
|
||||
if cssClass:
|
||||
style = 'class="%s"' % cssClass
|
||||
else:
|
||||
exec 'style = self.%sStyle' % type
|
||||
exec('style = self.%sStyle' % type)
|
||||
style = 'style="%s"' % style
|
||||
# The 'name' attribute of the tag indicates the type of the update.
|
||||
exec 'tagName = self.%sName' % type
|
||||
exec('tagName = self.%sName' % type)
|
||||
# The idea is: if there are several lines, every line must be surrounded
|
||||
# by a tag. This way, we know that a surrounding tag can't span several
|
||||
# lines, which is a prerequisite for managing cumulative diffs.
|
||||
if sep == ' ':
|
||||
if not isinstance(seq, basestring):
|
||||
if not isinstance(seq, str):
|
||||
seq = sep.join(seq)
|
||||
sep = ''
|
||||
if isinstance(seq, basestring):
|
||||
if isinstance(seq, str):
|
||||
return '%s<%s name="%s" %s title="%s">%s</%s>%s' % \
|
||||
(sep, tag, tagName, style, msg, seq, tag, sep)
|
||||
else:
|
||||
|
|
@ -592,7 +592,7 @@ class HtmlDiff:
|
|||
try:
|
||||
merger = Merger(lineA, add, previousDiffsA, self)
|
||||
add = merger.merge()
|
||||
except Merger.MergeError, e:
|
||||
except Merger.MergeError as e:
|
||||
# The merge algorithm has made a burn out. Simplify and
|
||||
# consider lineA has having been completely deleted and
|
||||
# lineB has completely inserted.
|
||||
|
|
|
|||
|
|
@ -239,14 +239,14 @@ class LdapConnector:
|
|||
self.server = ldap.initialize(self.serverUri)
|
||||
self.server.simple_bind_s(login, password)
|
||||
return True, None
|
||||
except AttributeError, ae:
|
||||
except AttributeError as ae:
|
||||
# When the ldap module is not there, trying to catch ldap.LDAPError
|
||||
# will raise an error.
|
||||
message = str(ae)
|
||||
self.log('Ldap connect error with login %s (%s).' % \
|
||||
(login, message))
|
||||
return False, message
|
||||
except ldap.LDAPError, le:
|
||||
except ldap.LDAPError as le:
|
||||
message = str(le)
|
||||
self.log('%s: connect error with login %s (%s).' % \
|
||||
(self.serverUri, login, message))
|
||||
|
|
@ -275,7 +275,7 @@ class LdapConnector:
|
|||
timeout=self.timeout)
|
||||
except ldap.TIMEOUT:
|
||||
pass
|
||||
except ldap.LDAPError, le:
|
||||
except ldap.LDAPError as le:
|
||||
self.log('LDAP query error %s: %s' % \
|
||||
(le.__class__.__name__, str(le)))
|
||||
# ------------------------------------------------------------------------------
|
||||
|
|
|
|||
|
|
@ -160,20 +160,20 @@ class Debianizer:
|
|||
name = '%s/%sctl' % (binFolder, self.appNameLower)
|
||||
f = file(name, 'w')
|
||||
f.write(appCtl % self.appNameLower)
|
||||
os.chmod(name, 0744) # Make it executable by owner.
|
||||
os.chmod(name, 0o744) # Make it executable by owner.
|
||||
f.close()
|
||||
# <app>run
|
||||
name = '%s/%srun' % (binFolder, self.appNameLower)
|
||||
f = file(name, 'w')
|
||||
f.write(appRun % self.appNameLower)
|
||||
os.chmod(name, 0744) # Make it executable by owner.
|
||||
os.chmod(name, 0o744) # Make it executable by owner.
|
||||
f.close()
|
||||
# startoo
|
||||
name = '%s/startoo' % binFolder
|
||||
f = file(name, 'w')
|
||||
f.write(ooStart)
|
||||
f.close()
|
||||
os.chmod(name, 0744) # Make it executable by owner.
|
||||
os.chmod(name, 0o744) # Make it executable by owner.
|
||||
# /var/lib/<app> (will store Data.fs, lock files, etc)
|
||||
varLibFolder = j(debFolder, 'var', 'lib', self.appNameLower)
|
||||
os.makedirs(varLibFolder)
|
||||
|
|
@ -208,7 +208,7 @@ class Debianizer:
|
|||
'application.' % n, '%sctl start' % n,
|
||||
'%sctl restart' % n, '%sctl stop' % n))
|
||||
f.close()
|
||||
os.chmod(name, 0744) # Make it executable by owner.
|
||||
os.chmod(name, 0o744) # Make it executable by owner.
|
||||
# /etc/init.d/oo (start OpenOffice at boot time)
|
||||
name = '%s/oo' % initdFolder
|
||||
f = file(name, 'w')
|
||||
|
|
@ -216,7 +216,7 @@ class Debianizer:
|
|||
'startoo', 'startoo', "#Can't stop OO."))
|
||||
f.write('\n')
|
||||
f.close()
|
||||
os.chmod(name, 0744) # Make it executable by owner.
|
||||
os.chmod(name, 0o744) # Make it executable by owner.
|
||||
# Get the size of the app, in Kb.
|
||||
os.chdir(tempFolder)
|
||||
cmd = subprocess.Popen(['du', '-b', '-s', 'debian'],
|
||||
|
|
|
|||
|
|
@ -25,8 +25,8 @@
|
|||
be strictly greater than 1.'''
|
||||
|
||||
# -----------------------------------------------------------------------------
|
||||
import re, sys, UserList, UserDict
|
||||
from StringIO import StringIO
|
||||
import re, sys, collections, UserDict
|
||||
from io import StringIO
|
||||
|
||||
# -----------------------------------------------------------------------------
|
||||
class ParserError(Exception): pass
|
||||
|
|
@ -69,7 +69,7 @@ LIST_VALUE_ERROR = 'Value "%s" is malformed: within it, %s. You should check ' \
|
|||
|
||||
# -----------------------------------------------------------------------------
|
||||
class Type:
|
||||
basicTypes = {'f': float, 'i':int, 'g':long, 'b':bool}
|
||||
basicTypes = {'f': float, 'i':int, 'g':int, 'b':bool}
|
||||
separators = ['-', ';', ',', ':']
|
||||
def __init__(self, typeDecl):
|
||||
self.basicType = None # The python basic type
|
||||
|
|
@ -85,12 +85,12 @@ class Type:
|
|||
self.listNumber += 1
|
||||
else:
|
||||
# Get the basic type
|
||||
if not (char in Type.basicTypes.keys()):
|
||||
if not (char in list(Type.basicTypes.keys())):
|
||||
raise TypeError(BASIC_TYPE_ERROR % char)
|
||||
self.basicType = Type.basicTypes[char]
|
||||
break
|
||||
if not self.basicType:
|
||||
self.basicType = unicode
|
||||
self.basicType = str
|
||||
def convertBasicValue(self, value):
|
||||
try:
|
||||
return self.basicType(value.strip())
|
||||
|
|
@ -136,7 +136,7 @@ class Type:
|
|||
elif not resIsComplete:
|
||||
try:
|
||||
res = self.convertListItem(value, separators)
|
||||
except TypeError, te:
|
||||
except TypeError as te:
|
||||
raise TypeError(LIST_VALUE_ERROR % (value, te, self.name))
|
||||
return res
|
||||
def convertListItem(self, stringItem, remainingSeps):
|
||||
|
|
@ -161,9 +161,9 @@ class Type:
|
|||
return self.name
|
||||
|
||||
# -----------------------------------------------------------------------------
|
||||
class Table(UserList.UserList):
|
||||
class Table(collections.UserList):
|
||||
def __init__(self):
|
||||
UserList.UserList.__init__(self)
|
||||
collections.UserList.__init__(self)
|
||||
self.name = None
|
||||
self.parent = None
|
||||
self.parentRow = None
|
||||
|
|
@ -213,7 +213,7 @@ class TableRow(UserDict.UserDict):
|
|||
via the parent table self.table.'''
|
||||
keyError = False
|
||||
t = self.table
|
||||
if self.has_key(key):
|
||||
if key in self:
|
||||
res = UserDict.UserDict.__getitem__(self, key)
|
||||
else:
|
||||
# Get the parent row
|
||||
|
|
@ -259,9 +259,9 @@ class TableRow(UserDict.UserDict):
|
|||
# -----------------------------------------------------------------------------
|
||||
class NameResolver:
|
||||
def resolveNames(self, tables):
|
||||
for tableName, table in tables.iteritems():
|
||||
for tableName, table in tables.items():
|
||||
if table.parent:
|
||||
if not tables.has_key(table.parent):
|
||||
if table.parent not in tables:
|
||||
raise ParserError(PARENT_NOT_FOUND %
|
||||
(table.parent, table.name))
|
||||
table.parent = tables[table.parent]
|
||||
|
|
@ -330,10 +330,10 @@ class TableParser:
|
|||
def manageSpecialChar(self):
|
||||
specialChar = int(self.specialCharBuffer)
|
||||
self.specialCharBuffer = ''
|
||||
if self.specialChars.has_key(specialChar):
|
||||
if specialChar in self.specialChars:
|
||||
self.contentBuffer.write(self.specialChars[specialChar])
|
||||
else:
|
||||
print('Warning: char %d not known.' % specialChar)
|
||||
print(('Warning: char %d not known.' % specialChar))
|
||||
self.state = TableParser.READING_CONTENT
|
||||
def bufferize(self, char):
|
||||
if self.state == TableParser.READING_CONTROL_WORD:
|
||||
|
|
@ -403,7 +403,7 @@ class TableParser:
|
|||
columnNames.append(name.strip())
|
||||
try:
|
||||
columnTypes.append(Type(typeDecl.strip()))
|
||||
except TypeError, te:
|
||||
except TypeError as te:
|
||||
raise ParserError(TYPE_ERROR %
|
||||
(header, self.currentTableName, te))
|
||||
else:
|
||||
|
|
@ -449,7 +449,7 @@ class TableParser:
|
|||
if columnType:
|
||||
try:
|
||||
columnValue = columnType.convertValue(columnValue)
|
||||
except TypeError, te:
|
||||
except TypeError as te:
|
||||
raise ParserError(VALUE_ERROR %
|
||||
(columnName, self.currentTableName,
|
||||
te))
|
||||
|
|
@ -496,7 +496,7 @@ class RtfTablesParser:
|
|||
# -----------------------------------------------------------------------------
|
||||
if __name__ =='__main__':
|
||||
tables = RtfTablesParser("Tests.rtf").parse()
|
||||
for key, item in tables.iteritems():
|
||||
print('Table %s' % key)
|
||||
for key, item in tables.items():
|
||||
print(('Table %s' % key))
|
||||
print(item)
|
||||
# -----------------------------------------------------------------------------
|
||||
|
|
|
|||
|
|
@ -74,7 +74,7 @@ class Sap:
|
|||
try:
|
||||
self.sap = pysap.Rfc_connection(conn_string = params)
|
||||
self.sap.open()
|
||||
except pysap.BaseSapRfcError, se:
|
||||
except pysap.BaseSapRfcError as se:
|
||||
# Put in the error message the connection string without the
|
||||
# password.
|
||||
connNoPasswd = params[:params.index('PASSWD')] + 'PASSWD=********'
|
||||
|
|
@ -84,7 +84,7 @@ class Sap:
|
|||
'''Create a struct corresponding to SAP/C structure definition
|
||||
p_structDef and fills it with dict p_userData.'''
|
||||
res = structDef()
|
||||
for name, value in userData.iteritems():
|
||||
for name, value in userData.items():
|
||||
if name not in structDef._sfield_names_:
|
||||
raise SapError(SAP_STRUCT_ELEM_NOT_FOUND % (paramName, name))
|
||||
sapType = structDef._sfield_sap_types_[name]
|
||||
|
|
@ -93,7 +93,7 @@ class Sap:
|
|||
sType = '%s%d' % (sapType[0], sapType[1])
|
||||
# "None" value is tolerated.
|
||||
if value == None: value = ''
|
||||
if not isinstance(value, basestring):
|
||||
if not isinstance(value, str):
|
||||
raise SapError(
|
||||
SAP_STRING_REQUIRED % (name, paramName, sType))
|
||||
if len(value) > sapType[1]:
|
||||
|
|
@ -113,7 +113,7 @@ class Sap:
|
|||
functionName = self.functionName
|
||||
function = self.sap.get_interface(functionName)
|
||||
# Specify the parameters
|
||||
for name, value in params.iteritems():
|
||||
for name, value in params.items():
|
||||
if type(value) == dict:
|
||||
# The param corresponds to a SAP/C "struct"
|
||||
v = self.createStructure(
|
||||
|
|
@ -140,7 +140,7 @@ class Sap:
|
|||
function[name] = v
|
||||
# Call the function
|
||||
function()
|
||||
except pysap.BaseSapRfcError, se:
|
||||
except pysap.BaseSapRfcError as se:
|
||||
raise SapError(SAP_FUNCTION_ERROR % (functionName, str(se)))
|
||||
return SapResult(function)
|
||||
|
||||
|
|
@ -198,10 +198,10 @@ class Sap:
|
|||
self.sap.get_structure(typeName)
|
||||
res += '%s\n%s\n\n' % \
|
||||
(typeName, self.getTypeInfo(typeName))
|
||||
except pysap.BaseSapRfcError, ee:
|
||||
except pysap.BaseSapRfcError as ee:
|
||||
pass
|
||||
return res
|
||||
except pysap.BaseSapRfcError, se:
|
||||
except pysap.BaseSapRfcError as se:
|
||||
if se.value == 'FU_NOT_FOUND':
|
||||
raise SapError(SAP_FUNCTION_NOT_FOUND % (functionName))
|
||||
else:
|
||||
|
|
@ -229,6 +229,6 @@ class Sap:
|
|||
'''Disconnects from SAP.'''
|
||||
try:
|
||||
self.sap.close()
|
||||
except pysap.BaseSapRfcError, se:
|
||||
except pysap.BaseSapRfcError as se:
|
||||
raise SapError(SAP_DISCONNECT_ERROR % str(se))
|
||||
# ------------------------------------------------------------------------------
|
||||
|
|
|
|||
|
|
@ -177,7 +177,7 @@ class Tester:
|
|||
(not isinstance(flavours, tuple)):
|
||||
raise TesterError(FLAVOURS_NOT_LIST)
|
||||
for flavour in flavours:
|
||||
if not isinstance(flavour, basestring):
|
||||
if not isinstance(flavour, str):
|
||||
raise TesterError(FLAVOUR_NOT_STRING)
|
||||
self.flavours = flavours
|
||||
self.flavour = None
|
||||
|
|
@ -198,7 +198,7 @@ class Tester:
|
|||
if self.flavour:
|
||||
ext = '.%s' % self.flavour
|
||||
configTableName = 'Configuration%s' % ext
|
||||
if self.tables.has_key(configTableName):
|
||||
if configTableName in self.tables:
|
||||
self.config = self.tables[configTableName].asDict()
|
||||
self.tempFolder = os.path.join(self.testFolder, 'temp')
|
||||
if os.path.exists(self.tempFolder):
|
||||
|
|
@ -249,11 +249,11 @@ class Tester:
|
|||
self.report.say('Test successful.\n')
|
||||
self.nbOfSuccesses += 1
|
||||
def run(self):
|
||||
assert self.tables.has_key('TestSuites'), \
|
||||
assert 'TestSuites' in self.tables, \
|
||||
TesterError(MAIN_TABLE_NOT_FOUND % self.testPlan)
|
||||
for testSuite in self.tables['TestSuites']:
|
||||
if (not testSuite.has_key('Name')) or \
|
||||
(not testSuite.has_key('Description')):
|
||||
if ('Name' not in testSuite) or \
|
||||
('Description' not in testSuite):
|
||||
raise TesterError(MAIN_TABLE_MALFORMED)
|
||||
if testSuite['Name'].startswith('_'):
|
||||
tsName = testSuite['Name'][1:]
|
||||
|
|
@ -261,8 +261,8 @@ class Tester:
|
|||
else:
|
||||
tsName = testSuite['Name']
|
||||
tsIgnored = False
|
||||
assert self.tables.has_key('%s.descriptions' % tsName) \
|
||||
and self.tables.has_key('%s.data' % tsName), \
|
||||
assert '%s.descriptions' % tsName in self.tables \
|
||||
and '%s.data' % tsName in self.tables, \
|
||||
TesterError(TEST_SUITE_NOT_FOUND % (tsName, tsName))
|
||||
assert len(self.tables['%s.descriptions' % tsName]) == \
|
||||
len(self.tables['%s.data' % tsName]), \
|
||||
|
|
|
|||
|
|
@ -44,7 +44,7 @@ class FolderDeleter:
|
|||
dirName = os.path.dirname(dirName)
|
||||
else:
|
||||
break
|
||||
except OSError, oe:
|
||||
except OSError:
|
||||
break
|
||||
|
||||
# ------------------------------------------------------------------------------
|
||||
|
|
@ -53,7 +53,7 @@ def cleanFolder(folder, exts=extsToClean, folders=(), verbose=False):
|
|||
'''This function allows to remove, in p_folder and subfolders, any file
|
||||
whose extension is in p_exts, and any folder whose name is in
|
||||
p_folders.'''
|
||||
if verbose: print('Cleaning folder %s...' % folder)
|
||||
if verbose: print(('Cleaning folder %s...' % folder))
|
||||
# Remove files with an extension listed in p_exts
|
||||
if exts:
|
||||
for root, dirs, files in os.walk(folder):
|
||||
|
|
@ -61,7 +61,7 @@ def cleanFolder(folder, exts=extsToClean, folders=(), verbose=False):
|
|||
ext = os.path.splitext(fileName)[1]
|
||||
if (ext in exts) or ext.endswith('~'):
|
||||
fileToRemove = os.path.join(root, fileName)
|
||||
if verbose: print('Removing file %s...' % fileToRemove)
|
||||
if verbose: print(('Removing file %s...' % fileToRemove))
|
||||
os.remove(fileToRemove)
|
||||
# Remove folders whose names are in p_folders.
|
||||
if folders:
|
||||
|
|
@ -69,7 +69,7 @@ def cleanFolder(folder, exts=extsToClean, folders=(), verbose=False):
|
|||
for folderName in dirs:
|
||||
if folderName in folders:
|
||||
toDelete = os.path.join(root, folderName)
|
||||
if verbose: print('Removing folder %s...' % toDelete)
|
||||
if verbose: print(('Removing folder %s...' % toDelete))
|
||||
FolderDeleter.delete(toDelete)
|
||||
|
||||
# ------------------------------------------------------------------------------
|
||||
|
|
@ -142,14 +142,14 @@ def copyData(data, target, targetMethod, type='string', encoding=None,
|
|||
dump(encodeData(chunk, encoding))
|
||||
elif type == 'zope':
|
||||
# A OFS.Image.File instance can be split into several chunks
|
||||
if isinstance(data.data, basestring): # One chunk
|
||||
if isinstance(data.data, str): # One chunk
|
||||
dump(encodeData(data.data, encoding))
|
||||
else:
|
||||
# Several chunks
|
||||
data = data.data
|
||||
while data is not None:
|
||||
dump(encodeData(data.data, encoding))
|
||||
data = data.next
|
||||
data = data.__next__
|
||||
|
||||
# ------------------------------------------------------------------------------
|
||||
def splitList(l, sub):
|
||||
|
|
@ -222,12 +222,12 @@ def getOsTempFolder():
|
|||
tmp = '/tmp'
|
||||
if os.path.exists(tmp) and os.path.isdir(tmp):
|
||||
res = tmp
|
||||
elif os.environ.has_key('TMP'):
|
||||
elif 'TMP' in os.environ:
|
||||
res = os.environ['TMP']
|
||||
elif os.environ.has_key('TEMP'):
|
||||
elif 'TEMP' in os.environ:
|
||||
res = os.environ['TEMP']
|
||||
else:
|
||||
raise "Sorry, I can't find a temp folder on your machine."
|
||||
raise Exception("Sorry, I can't find a temp folder on your machine.")
|
||||
return res
|
||||
|
||||
def getTempFileName(prefix='', extension=''):
|
||||
|
|
@ -273,10 +273,10 @@ def normalizeString(s, usage='fileName'):
|
|||
except UnicodeDecodeError:
|
||||
# Another encoding may be in use
|
||||
s = s.decode('latin-1')
|
||||
elif not isinstance(s, unicode): s = unicode(s)
|
||||
elif not isinstance(s, str): s = str(s)
|
||||
# For extracted text, replace any unwanted char with a blank
|
||||
if usage == 'extractedText':
|
||||
res = u''
|
||||
res = ''
|
||||
for char in s:
|
||||
if char not in extractIgnore: res += char
|
||||
else: res += ' '
|
||||
|
|
@ -291,7 +291,7 @@ def normalizeString(s, usage='fileName'):
|
|||
for char in s:
|
||||
if char not in fileNameIgnore: res += char
|
||||
elif usage.startswith('alpha'):
|
||||
exec 'rex = %sRex' % usage
|
||||
exec('rex = %sRex' % usage)
|
||||
res = ''
|
||||
for char in s:
|
||||
if rex.match(char): res += char
|
||||
|
|
@ -319,7 +319,7 @@ def keepDigits(s):
|
|||
def getStringDict(d):
|
||||
'''Gets the string literal corresponding to dict p_d.'''
|
||||
res = []
|
||||
for k, v in d.iteritems():
|
||||
for k, v in d.items():
|
||||
if type(v) not in sequenceTypes:
|
||||
if not isinstance(k, basestring): k = str(k)
|
||||
if not isinstance(v, basestring): v = str(v)
|
||||
|
|
@ -386,7 +386,7 @@ def formatNumber(n, sep=',', precision=2, tsep=' '):
|
|||
# ------------------------------------------------------------------------------
|
||||
def lower(s):
|
||||
'''French-accents-aware variant of string.lower.'''
|
||||
isUnicode = isinstance(s, unicode)
|
||||
isUnicode = isinstance(s, str)
|
||||
if not isUnicode: s = s.decode('utf-8')
|
||||
res = s.lower()
|
||||
if not isUnicode: res = res.encode('utf-8')
|
||||
|
|
@ -394,14 +394,14 @@ def lower(s):
|
|||
|
||||
def upper(s):
|
||||
'''French-accents-aware variant of string.upper.'''
|
||||
isUnicode = isinstance(s, unicode)
|
||||
isUnicode = isinstance(s, str)
|
||||
if not isUnicode: s = s.decode('utf-8')
|
||||
res = s.upper()
|
||||
if not isUnicode: res = res.encode('utf-8')
|
||||
return res
|
||||
|
||||
# ------------------------------------------------------------------------------
|
||||
typeLetters = {'b': bool, 'i': int, 'j': long, 'f':float, 's':str, 'u':unicode,
|
||||
typeLetters = {'b': bool, 'i': int, 'j': int, 'f':float, 's':str, 'u':str,
|
||||
'l': list, 'd': dict}
|
||||
caExts = {'py': ('.py', '.vpy', '.cpy'), 'xml': ('.pt', '.cpt', '.xml')}
|
||||
|
||||
|
|
@ -506,8 +506,8 @@ class CodeAnalysis:
|
|||
if not lines: return
|
||||
commentRate = (self.commentLines / float(lines)) * 100.0
|
||||
blankRate = (self.emptyLines / float(lines)) * 100.0
|
||||
print('%s: %d files, %d lines (%.0f%% comments, %.0f%% blank)' % \
|
||||
(self.name, self.numberOfFiles, lines, commentRate, blankRate))
|
||||
print(('%s: %d files, %d lines (%.0f%% comments, %.0f%% blank)' % \
|
||||
(self.name, self.numberOfFiles, lines, commentRate, blankRate)))
|
||||
|
||||
# ------------------------------------------------------------------------------
|
||||
class LinesCounter:
|
||||
|
|
@ -516,7 +516,7 @@ class LinesCounter:
|
|||
'%stemp' % os.sep)
|
||||
|
||||
def __init__(self, folderOrModule, excludes=None):
|
||||
if isinstance(folderOrModule, basestring):
|
||||
if isinstance(folderOrModule, str):
|
||||
# It is the path of some folder
|
||||
self.folder = folderOrModule
|
||||
else:
|
||||
|
|
@ -624,10 +624,10 @@ class FileWrapper:
|
|||
if self.content.__class__.__name__ == 'Pdata':
|
||||
# The file content is splitted in several chunks.
|
||||
f.write(self.content.data)
|
||||
nextPart = self.content.next
|
||||
nextPart = self.content.__next__
|
||||
while nextPart:
|
||||
f.write(nextPart.data)
|
||||
nextPart = nextPart.next
|
||||
nextPart = nextPart.__next__
|
||||
else:
|
||||
# Only one chunk
|
||||
f.write(self.content)
|
||||
|
|
|
|||
|
|
@ -66,9 +66,9 @@ HTML_ENTITIES = {
|
|||
'euro':'€', 'nbsp':' ', "rsquo":"'", "lsquo":"'", "ldquo":"'",
|
||||
"rdquo":"'", 'ndash': '—', 'mdash': '—', 'oelig':'oe', 'quot': "'",
|
||||
'mu': 'µ'}
|
||||
import htmlentitydefs
|
||||
for k, v in htmlentitydefs.entitydefs.iteritems():
|
||||
if not HTML_ENTITIES.has_key(k) and not XML_ENTITIES.has_key(k):
|
||||
import html.entities
|
||||
for k, v in html.entities.entitydefs.items():
|
||||
if k not in HTML_ENTITIES and k not in XML_ENTITIES:
|
||||
HTML_ENTITIES[k] = ''
|
||||
|
||||
def escapeXml(s, format='xml', nsText='text'):
|
||||
|
|
@ -77,13 +77,13 @@ def escapeXml(s, format='xml', nsText='text'):
|
|||
their ODF counterparts. In this case, it is needed to give the name of
|
||||
the "text" namespace (p_nsText) as defined in the ODF document where the
|
||||
line breaks and tabs must be inserted.'''
|
||||
if isinstance(s, unicode):
|
||||
res = u''
|
||||
if isinstance(s, str):
|
||||
res = ''
|
||||
else:
|
||||
res = ''
|
||||
odf = format == 'odf'
|
||||
for c in s:
|
||||
if XML_SPECIAL_CHARS_NO_APOS.has_key(c):
|
||||
if c in XML_SPECIAL_CHARS_NO_APOS:
|
||||
# We do not escape 'apos': there is no particular need for that.
|
||||
res += XML_SPECIAL_CHARS_NO_APOS[c]
|
||||
elif odf and (c == '\n'):
|
||||
|
|
@ -99,12 +99,12 @@ def escapeXml(s, format='xml', nsText='text'):
|
|||
def escapeXhtml(s):
|
||||
'''Return p_s, whose XHTML special chars and carriage return chars have
|
||||
been replaced with corresponding XHTML entities.'''
|
||||
if isinstance(s, unicode):
|
||||
res = u''
|
||||
if isinstance(s, str):
|
||||
res = ''
|
||||
else:
|
||||
res = ''
|
||||
for c in s:
|
||||
if XML_SPECIAL_CHARS_NO_APOS.has_key(c):
|
||||
if c in XML_SPECIAL_CHARS_NO_APOS:
|
||||
res += XML_SPECIAL_CHARS_NO_APOS[c]
|
||||
elif c == '\n':
|
||||
res += '<br/>'
|
||||
|
|
@ -144,7 +144,7 @@ class XmlElement:
|
|||
res = self.elem
|
||||
if self.attrs:
|
||||
res += '('
|
||||
for attrName, attrValue in self.attrs.items():
|
||||
for attrName, attrValue in list(self.attrs.items()):
|
||||
res += '%s="%s"' % (attrName, attrValue)
|
||||
res += ')'
|
||||
return res
|
||||
|
|
@ -167,7 +167,7 @@ class XmlEnvironment:
|
|||
self.parser = None
|
||||
def manageNamespaces(self, attrs):
|
||||
'''Manages namespaces definitions encountered in p_attrs.'''
|
||||
for attrName, attrValue in attrs.items():
|
||||
for attrName, attrValue in list(attrs.items()):
|
||||
if attrName.startswith('xmlns:'):
|
||||
self.namespaces[attrValue] = attrName[6:]
|
||||
def ns(self, nsUri):
|
||||
|
|
@ -221,7 +221,7 @@ class XmlParser(ContentHandler, ErrorHandler):
|
|||
def skippedEntity(self, name):
|
||||
'''This method is called every time expat does not recognize an entity.
|
||||
We provide here support for HTML entities.'''
|
||||
if HTML_ENTITIES.has_key(name):
|
||||
if name in HTML_ENTITIES:
|
||||
self.characters(HTML_ENTITIES[name].decode('utf-8'))
|
||||
else:
|
||||
# Put a question mark instead of raising an exception.
|
||||
|
|
@ -230,10 +230,10 @@ class XmlParser(ContentHandler, ErrorHandler):
|
|||
# ErrorHandler methods ---------------------------------------------------
|
||||
def error(self, error):
|
||||
if self.raiseOnError: raise error
|
||||
else: print('SAX error %s' % str(error))
|
||||
else: print(('SAX error %s' % str(error)))
|
||||
def fatalError(self, error):
|
||||
if self.raiseOnError: raise error
|
||||
else: print('SAX fatal error %s' % str(error))
|
||||
else: print(('SAX fatal error %s' % str(error)))
|
||||
def warning(self, error): pass
|
||||
|
||||
def parse(self, xml, source='string'):
|
||||
|
|
@ -246,9 +246,9 @@ class XmlParser(ContentHandler, ErrorHandler):
|
|||
method will close it.
|
||||
'''
|
||||
try:
|
||||
from cStringIO import StringIO
|
||||
from io import StringIO
|
||||
except ImportError:
|
||||
from StringIO import StringIO
|
||||
from io import StringIO
|
||||
self._xml = xml
|
||||
self.parser.setContentHandler(self)
|
||||
self.parser.setErrorHandler(self)
|
||||
|
|
@ -333,7 +333,7 @@ class XmlUnmarshaller(XmlParser):
|
|||
def convertAttrs(self, attrs):
|
||||
'''Converts XML attrs to a dict.'''
|
||||
res = {}
|
||||
for k, v in attrs.items():
|
||||
for k, v in list(attrs.items()):
|
||||
if ':' in k: # An attr prefixed with a namespace. Remove this.
|
||||
k = k.split(':')[-1]
|
||||
res[str(k)] = self.encode(v)
|
||||
|
|
@ -362,9 +362,9 @@ class XmlUnmarshaller(XmlParser):
|
|||
e = XmlParser.startElement(self, elem, attrs)
|
||||
# Determine the type of the element.
|
||||
elemType = 'unicode' # Default value
|
||||
if attrs.has_key('type'):
|
||||
if 'type' in attrs:
|
||||
elemType = attrs['type']
|
||||
elif self.tagTypes.has_key(elem):
|
||||
elif elem in self.tagTypes:
|
||||
elemType = self.tagTypes[elem]
|
||||
if elemType in self.containerTags:
|
||||
# I must create a new container object.
|
||||
|
|
@ -375,9 +375,9 @@ class XmlUnmarshaller(XmlParser):
|
|||
elif elemType == 'dict': newObject = {}
|
||||
elif elemType == 'file':
|
||||
newObject = UnmarshalledFile()
|
||||
if attrs.has_key('name'):
|
||||
if 'name' in attrs:
|
||||
newObject.name = self.encode(attrs['name'])
|
||||
if attrs.has_key('mimeType'):
|
||||
if 'mimeType' in attrs:
|
||||
newObject.mimeType = self.encode(attrs['mimeType'])
|
||||
else: newObject = Object(**self.convertAttrs(attrs))
|
||||
# Store the value on the last container, or on the root object.
|
||||
|
|
@ -454,17 +454,17 @@ class XmlUnmarshaller(XmlParser):
|
|||
if not value: value = None
|
||||
else:
|
||||
# If we have a custom converter for values of this type, use it.
|
||||
if self.conversionFunctions.has_key(e.currentBasicType):
|
||||
if e.currentBasicType in self.conversionFunctions:
|
||||
try:
|
||||
value = self.conversionFunctions[e.currentBasicType](
|
||||
value)
|
||||
except Exception, err:
|
||||
except Exception as err:
|
||||
raise AppyError(CUSTOM_CONVERSION_ERROR % (
|
||||
e.currentBasicType, value, str(err)))
|
||||
# If not, try a standard conversion
|
||||
elif e.currentBasicType in self.numericTypes:
|
||||
try:
|
||||
exec 'value = %s' % value
|
||||
exec('value = %s' % value)
|
||||
except SyntaxError:
|
||||
raise AppyError(CONVERSION_ERROR % (
|
||||
e.currentBasicType, value))
|
||||
|
|
@ -578,7 +578,7 @@ class XmlMarshaller:
|
|||
tagName = self.getTagName(self.rootElementName)
|
||||
res.write('<'); res.write(tagName)
|
||||
# Dumps namespace definitions if any
|
||||
for prefix, url in self.namespaces.iteritems():
|
||||
for prefix, url in self.namespaces.items():
|
||||
if not prefix:
|
||||
pre = 'xmlns' # The default namespace
|
||||
else:
|
||||
|
|
@ -597,7 +597,7 @@ class XmlMarshaller:
|
|||
s = s.decode('utf-8')
|
||||
# Replace special chars by XML entities
|
||||
for c in s:
|
||||
if self.xmlEntities.has_key(c):
|
||||
if c in self.xmlEntities:
|
||||
res.write(self.xmlEntities[c])
|
||||
else:
|
||||
res.write(c)
|
||||
|
|
@ -617,13 +617,13 @@ class XmlMarshaller:
|
|||
# There will be several parts.
|
||||
w(v.data.data.encode('base64'))
|
||||
# Write subsequent parts
|
||||
nextPart = v.data.next
|
||||
nextPart = v.data.__next__
|
||||
nextPartNb = 2
|
||||
while nextPart:
|
||||
w('</%s>' % partTag) # Close the previous part
|
||||
w('<%s type="base64" number="%d">' % (partTag, nextPartNb))
|
||||
w(nextPart.data.encode('base64'))
|
||||
nextPart = nextPart.next
|
||||
nextPart = nextPart.__next__
|
||||
nextPartNb += 1
|
||||
else:
|
||||
w(v.data.encode('base64'))
|
||||
|
|
@ -654,7 +654,7 @@ class XmlMarshaller:
|
|||
|
||||
def dumpDict(self, res, v):
|
||||
'''Dumps the XML version of dict p_v.'''
|
||||
for key, value in v.iteritems():
|
||||
for key, value in v.items():
|
||||
res.write('<entry type="object">')
|
||||
self.dumpField(res, 'k', key)
|
||||
self.dumpField(res, 'v', value)
|
||||
|
|
@ -681,7 +681,7 @@ class XmlMarshaller:
|
|||
# The previous condition must be checked before this one because
|
||||
# referred objects may be stored in lists or tuples, too.
|
||||
for elem in value: self.dumpField(res, 'e', elem)
|
||||
elif isinstance(value, basestring): self.dumpString(res, value)
|
||||
elif isinstance(value, str): self.dumpString(res, value)
|
||||
elif isinstance(value, bool): res.write(self.trueFalse[value])
|
||||
elif fieldType == 'object':
|
||||
if hasattr(value, 'absolute_url'):
|
||||
|
|
@ -689,7 +689,7 @@ class XmlMarshaller:
|
|||
res.write(value.absolute_url())
|
||||
else:
|
||||
# Dump the entire object content
|
||||
for k, v in value.__dict__.iteritems():
|
||||
for k, v in value.__dict__.items():
|
||||
if not k.startswith('__'):
|
||||
self.dumpField(res, k, v)
|
||||
# Maybe we could add a parameter to the marshaller to know how
|
||||
|
|
@ -771,7 +771,7 @@ class XmlMarshaller:
|
|||
rootTagName = self.dumpRootTag(res, instance)
|
||||
# Dump the fields of this root object
|
||||
if objectType == 'popo':
|
||||
for fieldName, fieldValue in instance.__dict__.iteritems():
|
||||
for fieldName, fieldValue in instance.__dict__.items():
|
||||
mustDump = False
|
||||
if fieldName in self.fieldsToExclude:
|
||||
mustDump = False
|
||||
|
|
@ -823,11 +823,11 @@ class XmlMarshaller:
|
|||
histTag = self.getTagName('history')
|
||||
eventTag = self.getTagName('event')
|
||||
res.write('<%s type="list">' % histTag)
|
||||
key = instance.workflow_history.keys()[0]
|
||||
key = list(instance.workflow_history.keys())[0]
|
||||
history = instance.workflow_history[key]
|
||||
for event in history:
|
||||
res.write('<%s type="object">' % eventTag)
|
||||
for k, v in event.iteritems():
|
||||
for k, v in event.items():
|
||||
self.dumpField(res, k, v)
|
||||
res.write('</%s>' % eventTag)
|
||||
res.write('</%s>' % histTag)
|
||||
|
|
@ -856,7 +856,7 @@ class XmlHandler(ContentHandler):
|
|||
(like dates) from a file that need to be compared to another file.'''
|
||||
def __init__(self, xmlTagsToIgnore, xmlAttrsToIgnore):
|
||||
ContentHandler.__init__(self)
|
||||
self.res = unicode(xmlPrologue)
|
||||
self.res = str(xmlPrologue)
|
||||
self.namespaces = {} # ~{s_namespaceUri:s_namespaceName}~
|
||||
self.indentLevel = -1
|
||||
self.tabWidth = 3
|
||||
|
|
@ -891,7 +891,7 @@ class XmlHandler(ContentHandler):
|
|||
self.res += '\n' + (' ' * self.indentLevel * self.tabWidth)
|
||||
def manageNamespaces(self, attrs):
|
||||
'''Manage namespaces definitions encountered in attrs'''
|
||||
for attrName, attrValue in attrs.items():
|
||||
for attrName, attrValue in list(attrs.items()):
|
||||
if attrName.startswith('xmlns:'):
|
||||
self.namespaces[attrValue] = attrName[6:]
|
||||
def ns(self, nsUri):
|
||||
|
|
@ -906,7 +906,7 @@ class XmlHandler(ContentHandler):
|
|||
self.indentLevel += 1
|
||||
self.dumpSpaces()
|
||||
self.res += '<%s' % elem
|
||||
attrsNames = attrs.keys()
|
||||
attrsNames = list(attrs.keys())
|
||||
attrsNames.sort()
|
||||
for attrToIgnore in self.attrsToIgnore:
|
||||
if attrToIgnore in attrsNames:
|
||||
|
|
@ -986,7 +986,7 @@ class XmlComparator:
|
|||
else: print(line)
|
||||
else:
|
||||
if report: report.say(line[:-1], encoding=encoding)
|
||||
else: print(line[:-1])
|
||||
else: print((line[:-1]))
|
||||
lastLinePrinted = True
|
||||
else:
|
||||
lastLinePrinted = False
|
||||
|
|
@ -1061,7 +1061,7 @@ class XhtmlCleaner(XmlParser):
|
|||
self.env.ignoreContent = False
|
||||
try:
|
||||
res = self.parse('<x>%s</x>' % s).encode('utf-8')
|
||||
except SAXParseException, e:
|
||||
except SAXParseException as e:
|
||||
raise self.Error(str(e))
|
||||
return res
|
||||
|
||||
|
|
@ -1106,7 +1106,7 @@ class XhtmlCleaner(XmlParser):
|
|||
prefix = ''
|
||||
res = '%s<%s' % (prefix, elem)
|
||||
# Include the found attributes, excepted those that must be ignored.
|
||||
for name, value in attrs.items():
|
||||
for name, value in list(attrs.items()):
|
||||
if not self.keepStyles:
|
||||
if name in self.attrsToIgnore: continue
|
||||
elif name == 'style':
|
||||
|
|
@ -1115,7 +1115,7 @@ class XhtmlCleaner(XmlParser):
|
|||
res += ' %s="%s"' % (name, value)
|
||||
# Include additional attributes if required.
|
||||
if elem in self.attrsToAdd:
|
||||
for name, value in self.attrsToAdd[elem].iteritems():
|
||||
for name, value in self.attrsToAdd[elem].items():
|
||||
res += ' %s="%s"' % (name, value)
|
||||
# Close the tag if it is a no-end tag
|
||||
if elem in self.noEndTags:
|
||||
|
|
@ -1163,7 +1163,7 @@ class XhtmlCleaner(XmlParser):
|
|||
# I give here to lstrip an explicit list of what is to be considered
|
||||
# as blank chars, because I do not want unicode NBSP chars to be in
|
||||
# this list.
|
||||
toAdd = content.lstrip(u' \n\r\t')
|
||||
toAdd = content.lstrip(' \n\r\t')
|
||||
else:
|
||||
toAdd = content
|
||||
# Re-transform XML special chars to entities.
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue