[Checkins] SVN: Products.GenericSetup/branches/upgrade-upgrade-api/Products/GenericSetup/registry.py pyflakes, pep8
Godefroid Chapelle
gotcha at bubblenet.be
Mon May 23 09:14:18 EDT 2011
Log message for revision 121775:
pyflakes, pep8
There is no pep8 compliant way of declaring security...
So some complaints are left.
Changed:
U Products.GenericSetup/branches/upgrade-upgrade-api/Products/GenericSetup/registry.py
-=-
Modified: Products.GenericSetup/branches/upgrade-upgrade-api/Products/GenericSetup/registry.py
===================================================================
--- Products.GenericSetup/branches/upgrade-upgrade-api/Products/GenericSetup/registry.py 2011-05-23 13:11:39 UTC (rev 121774)
+++ Products.GenericSetup/branches/upgrade-upgrade-api/Products/GenericSetup/registry.py 2011-05-23 13:14:18 UTC (rev 121775)
@@ -69,85 +69,86 @@
security = ClassSecurityInfo()
security.declareObjectPrivate()
- security.setDefaultAccess( 'deny' )
+ security.setDefaultAccess('deny')
- def __init__( self, encoding ):
+ def __init__(self, encoding):
self._encoding = encoding
self._required = {}
self._forbidden = []
- def startElement( self, name, attrs ):
+ def startElement(self, name, attrs):
if name == 'tool-setup':
pass
elif name == 'forbidden':
- tool_id = self._extract( attrs, 'tool_id' )
+ tool_id = self._extract(attrs, 'tool_id')
if tool_id not in self._forbidden:
- self._forbidden.append( tool_id )
+ self._forbidden.append(tool_id)
elif name == 'required':
- tool_id = self._extract( attrs, 'tool_id' )
- dotted_name = self._extract( attrs, 'class' )
- self._required[ tool_id ] = dotted_name
+ tool_id = self._extract(attrs, 'tool_id')
+ dotted_name = self._extract(attrs, 'class')
+ self._required[tool_id] = dotted_name
else:
- raise ValueError, 'Unknown element %s' % name
+ raise ValueError('Unknown element %s' % name)
-InitializeClass( _ToolsetParser )
+InitializeClass(_ToolsetParser)
+
class _ImportStepRegistryParser(_HandlerBase):
security = ClassSecurityInfo()
security.declareObjectPrivate()
- security.setDefaultAccess( 'deny' )
+ security.setDefaultAccess('deny')
- def __init__( self, encoding ):
+ def __init__(self, encoding):
self._encoding = encoding
self._started = False
self._pending = None
self._parsed = []
- def startElement( self, name, attrs ):
+ def startElement(self, name, attrs):
if name == 'import-steps':
if self._started:
- raise ValueError, 'Duplicated setup-steps element: %s' % name
+ raise ValueError('Duplicated setup-steps element: %s' % name)
self._started = True
elif name == 'import-step':
if self._pending is not None:
- raise ValueError, 'Cannot nest setup-step elements'
+ raise ValueError('Cannot nest setup-step elements')
- self._pending = dict( [ ( k, self._extract( attrs, k ) )
- for k in attrs.keys() ] )
+ self._pending = dict([(k, self._extract(attrs, k))
+ for k in attrs.keys()])
- self._pending[ 'dependencies' ] = []
+ self._pending['dependencies'] = []
elif name == 'dependency':
if not self._pending:
- raise ValueError, 'Dependency outside of step'
+ raise ValueError('Dependency outside of step')
- depended = self._extract( attrs, 'step' )
- self._pending[ 'dependencies' ].append( depended )
+ depended = self._extract(attrs, 'step')
+ self._pending['dependencies'].append(depended)
else:
- raise ValueError, 'Unknown element %s' % name
+ raise ValueError('Unknown element %s' % name)
- def characters( self, content ):
+ def characters(self, content):
if self._pending is not None:
- content = self._encode( content )
- self._pending.setdefault( 'description', [] ).append( content )
+ content = self._encode(content)
+ self._pending.setdefault('description', []).append(content)
def endElement(self, name):
@@ -157,58 +158,58 @@
elif name == 'import-step':
if self._pending is None:
- raise ValueError, 'No pending step!'
+ raise ValueError('No pending step!')
- deps = tuple( self._pending[ 'dependencies' ] )
- self._pending[ 'dependencies' ] = deps
+ deps = tuple(self._pending['dependencies'])
+ self._pending['dependencies'] = deps
- desc = ''.join( self._pending[ 'description' ] )
- self._pending[ 'description' ] = desc
+ desc = ''.join(self._pending['description'])
+ self._pending['description'] = desc
- self._parsed.append( self._pending )
+ self._parsed.append(self._pending)
self._pending = None
-InitializeClass( _ImportStepRegistryParser )
+InitializeClass(_ImportStepRegistryParser)
class _ExportStepRegistryParser(_HandlerBase):
security = ClassSecurityInfo()
security.declareObjectPrivate()
- security.setDefaultAccess( 'deny' )
+ security.setDefaultAccess('deny')
- def __init__( self, encoding ):
+ def __init__(self, encoding):
self._encoding = encoding
self._started = False
self._pending = None
self._parsed = []
- def startElement( self, name, attrs ):
+ def startElement(self, name, attrs):
if name == 'export-steps':
if self._started:
- raise ValueError, 'Duplicated export-steps element: %s' % name
+ raise ValueError('Duplicated export-steps element: %s' % name)
self._started = True
elif name == 'export-step':
if self._pending is not None:
- raise ValueError, 'Cannot nest export-step elements'
+ raise ValueError('Cannot nest export-step elements')
- self._pending = dict( [ ( k, self._extract( attrs, k ) )
- for k in attrs.keys() ] )
+ self._pending = dict([(k, self._extract(attrs, k))
+ for k in attrs.keys()])
else:
- raise ValueError, 'Unknown element %s' % name
+ raise ValueError('Unknown element %s' % name)
- def characters( self, content ):
+ def characters(self, content):
if self._pending is not None:
- content = self._encode( content )
- self._pending.setdefault( 'description', [] ).append( content )
+ content = self._encode(content)
+ self._pending.setdefault('description', []).append(content)
def endElement(self, name):
@@ -218,15 +219,15 @@
elif name == 'export-step':
if self._pending is None:
- raise ValueError, 'No pending step!'
+ raise ValueError('No pending step!')
- desc = ''.join( self._pending[ 'description' ] )
- self._pending[ 'description' ] = desc
+ desc = ''.join(self._pending['description'])
+ self._pending['description'] = desc
- self._parsed.append( self._pending )
+ self._parsed.append(self._pending)
self._pending = None
-InitializeClass( _ExportStepRegistryParser )
+InitializeClass(_ExportStepRegistryParser)
class GlobalRegistryStorage(object):
@@ -241,7 +242,8 @@
def values(self):
sm = getGlobalSiteManager()
- values = [info for name, info in sm.getUtilitiesFor(self.interfaceClass)]
+ values = [info for name, info in
+ sm.getUtilitiesFor(self.interfaceClass)]
return values
def get(self, key):
@@ -260,25 +262,26 @@
for key in self.keys():
del self[key]
-class BaseStepRegistry( Implicit ):
+class BaseStepRegistry(Implicit):
+
security = ClassSecurityInfo()
- def __init__( self, store=None ):
+ def __init__(self, store=None):
if store is None:
store = {}
self._registered = store
self.clear()
- security.declareProtected( ManagePortal, 'listSteps' )
- def listSteps( self ):
+ security.declareProtected(ManagePortal, 'listSteps')
+ def listSteps(self):
""" Return a list of registered step IDs.
"""
return self._registered.keys()
- security.declareProtected( ManagePortal, 'getStepMetadata' )
- def getStepMetadata( self, key, default=None ):
+ security.declareProtected(ManagePortal, 'getStepMetadata')
+ def getStepMetadata(self, key, default=None):
""" Return a mapping of metadata for the step identified by 'key'.
@@ -286,18 +289,18 @@
o The 'handler' metadata is available via 'getStep'.
"""
- info = self._registered.get( key )
+ info = self._registered.get(key)
if info is None:
return default
result = info.copy()
- result['invalid'] = _resolveDottedName( result[ 'handler' ] ) is None
+ result['invalid'] = _resolveDottedName(result['handler']) is None
return result
- security.declareProtected( ManagePortal, 'listStepMetadata' )
- def listStepMetadata( self ):
+ security.declareProtected(ManagePortal, 'listStepMetadata')
+ def listStepMetadata(self):
""" Return a sequence of mappings describing registered steps.
@@ -305,10 +308,10 @@
"""
step_ids = self.listSteps()
step_ids.sort()
- return [ self.getStepMetadata( x ) for x in step_ids ]
+ return [self.getStepMetadata(x) for x in step_ids]
- security.declareProtected( ManagePortal, 'generateXML' )
- def generateXML( self ):
+ security.declareProtected(ManagePortal, 'generateXML')
+ def generateXML(self):
""" Return a round-trippable XML representation of the registry.
@@ -316,47 +319,48 @@
"""
return self._exportTemplate()
- security.declarePrivate( 'getStep' )
- def getStep( self, key, default=None ):
+ security.declarePrivate('getStep')
+ def getStep(self, key, default=None):
""" Return the I(Export|Import)Plugin registered for 'key'.
o Return 'default' if no such step is registered.
"""
- info = self._registered.get( key )
+ info = self._registered.get(key)
if info is None:
return default
- return _resolveDottedName( info[ 'handler' ] )
+ return _resolveDottedName(info['handler'])
- security.declarePrivate( 'unregisterStep' )
- def unregisterStep( self, id ):
- del self._registered[ id ]
+ security.declarePrivate('unregisterStep')
+ def unregisterStep(self, id):
+ del self._registered[id]
- security.declarePrivate( 'clear' )
- def clear( self ):
+ security.declarePrivate('clear')
+ def clear(self):
self._registered.clear()
- security.declarePrivate( 'parseXML' )
- def parseXML( self, text, encoding=None ):
+ security.declarePrivate('parseXML')
+ def parseXML(self, text, encoding=None):
""" Parse 'text'.
"""
- reader = getattr( text, 'read', None )
+ reader = getattr(text, 'read', None)
if reader is not None:
text = reader()
- parser = self.RegistryParser( encoding )
- parseString( text, parser )
+ parser = self.RegistryParser(encoding)
+ parseString(text, parser)
return parser._parsed
-InitializeClass( BaseStepRegistry )
+InitializeClass(BaseStepRegistry)
-class ImportStepRegistry( BaseStepRegistry ):
+class ImportStepRegistry(BaseStepRegistry):
+
""" Manage knowledge about steps to create / configure site.
o Steps are composed together to define a site profile.
@@ -366,10 +370,9 @@
security = ClassSecurityInfo()
RegistryParser = _ImportStepRegistryParser
+ security.declareProtected(ManagePortal, 'sortSteps')
+ def sortSteps(self):
- security.declareProtected( ManagePortal, 'sortSteps' )
- def sortSteps( self ):
-
""" Return a sequence of registered step IDs
o Sequence is sorted topologically by dependency, with the dependent
@@ -377,10 +380,10 @@
"""
return self._computeTopologicalSort()
- security.declareProtected( ManagePortal, 'checkComplete' )
- def checkComplete( self ):
+ security.declareProtected(ManagePortal, 'checkComplete')
+ def checkComplete(self):
- """ Return a sequence of ( node, edge ) tuples for unsatisifed deps.
+ """ Return a sequence of (node, edge) tuples for unsatisifed deps.
"""
result = []
seen = {}
@@ -389,26 +392,20 @@
for node in graph:
- dependencies = self.getStepMetadata( node )[ 'dependencies' ]
+ dependencies = self.getStepMetadata(node)['dependencies']
for dependency in dependencies:
- if seen.get( dependency ) is None:
- result.append( ( node, dependency ) )
+ if seen.get(dependency) is None:
+ result.append((node, dependency))
- seen[ node ] = 1
+ seen[node] = 1
return result
- security.declarePrivate( 'registerStep' )
- def registerStep( self
- , id
- , version=None
- , handler=None
- , dependencies=()
- , title=None
- , description=None
- ):
+ security.declarePrivate('registerStep')
+ def registerStep(self, id, version=None, handler=None, dependencies=(),
+ title=None, description=None):
""" Register a setup step.
o 'id' is a unique name for this step,
@@ -439,64 +436,63 @@
If None, the remaining line of the documentation string of
the handler is used, or default to ''.
"""
- already = self.getStepMetadata( id )
+ already = self.getStepMetadata(id)
if handler is None:
- raise ValueError, 'No handler specified'
+ raise ValueError('No handler specified')
- if already and already[ 'version' ] > version:
- raise KeyError( 'Existing registration for step %s, version %s'
- % ( id, already[ 'version' ] ) )
+ if already and already['version'] > version:
+ raise KeyError('Existing registration for step %s, version %s'
+ % (id, already['version']))
if not isinstance(handler, str):
- handler = _getDottedName( handler )
+ handler = _getDottedName(handler)
if title is None or description is None:
method = _resolveDottedName(handler)
if method is None:
- t,d = id, ''
+ t, d = id, ''
else:
- t, d = _extractDocstring( method, id, '' )
+ t, d = _extractDocstring(method, id, '')
title = title or t
description = description or d
- info = { 'id' : id
- , 'version' : version
- , 'handler' : handler
- , 'dependencies' : dependencies
- , 'title' : title
- , 'description' : description
+ info = {'id': id,
+ 'version': version,
+ 'handler': handler,
+ 'dependencies': dependencies,
+ 'title': title,
+ 'description': description,
}
- self._registered[ id ] = info
+ self._registered[id] = info
-
#
# Helper methods
#
- security.declarePrivate( '_computeTopologicalSort' )
- def _computeTopologicalSort( self ):
+ security.declarePrivate('_computeTopologicalSort')
+ def _computeTopologicalSort(self):
return _computeTopologicalSort(self._registered.values())
+ security.declarePrivate('_exportTemplate')
+ _exportTemplate = PageTemplateFile('isrExport.xml', _xmldir)
- security.declarePrivate( '_exportTemplate' )
- _exportTemplate = PageTemplateFile( 'isrExport.xml', _xmldir )
+InitializeClass(ImportStepRegistry)
-InitializeClass( ImportStepRegistry )
-
_import_step_registry = ImportStepRegistry(GlobalRegistryStorage(IImportStep))
-class ExportStepRegistry( BaseStepRegistry ):
+class ExportStepRegistry(BaseStepRegistry):
+
""" Registry of known site-configuration export steps.
o Each step is registered with a unique id.
o When called, with the portal object passed in as an argument,
the step must return a sequence of three-tuples,
- ( 'data', 'content_type', 'filename' ), one for each file exported
+ ('data', 'content_type', 'filename'), one for each file exported
by the step.
- 'data' is a string containing the file data;
@@ -511,8 +507,8 @@
security = ClassSecurityInfo()
RegistryParser = _ExportStepRegistryParser
- security.declarePrivate( 'registerStep' )
- def registerStep( self, id, handler, title=None, description=None ):
+ security.declarePrivate('registerStep')
+ def registerStep(self, id, handler, title=None, description=None):
""" Register an export step.
@@ -530,141 +526,138 @@
the step is used, or default to ''.
"""
if not isinstance(handler, str):
- handler = _getDottedName( handler )
+ handler = _getDottedName(handler)
if title is None or description is None:
method = _resolveDottedName(handler)
if method is None:
- t,d = id, ''
+ t, d = id, ''
else:
- t, d = _extractDocstring( method, id, '' )
+ t, d = _extractDocstring(method, id, '')
title = title or t
description = description or d
- info = { 'id' : id
- , 'handler' : handler
- , 'title' : title
- , 'description' : description
+ info = {'id': id,
+ 'handler': handler,
+ 'title': title,
+ 'description': description,
}
- self._registered[ id ] = info
+ self._registered[id] = info
-
#
# Helper methods
#
- security.declarePrivate( '_exportTemplate' )
- _exportTemplate = PageTemplateFile( 'esrExport.xml', _xmldir )
+ security.declarePrivate('_exportTemplate')
+ _exportTemplate = PageTemplateFile('esrExport.xml', _xmldir)
-InitializeClass( ExportStepRegistry )
+InitializeClass(ExportStepRegistry)
_export_step_registry = ExportStepRegistry(GlobalRegistryStorage(IExportStep))
-class ToolsetRegistry( Implicit ):
+class ToolsetRegistry(Implicit):
""" Track required / forbidden tools.
"""
implements(IToolsetRegistry)
security = ClassSecurityInfo()
- security.setDefaultAccess( 'allow' )
+ security.setDefaultAccess('allow')
- def __init__( self ):
+ def __init__(self):
self.clear()
#
# Toolset API
#
- security.declareProtected( ManagePortal, 'listForbiddenTools' )
- def listForbiddenTools( self ):
+ security.declareProtected(ManagePortal, 'listForbiddenTools')
+ def listForbiddenTools(self):
""" See IToolsetRegistry.
"""
- result = list( self._forbidden )
+ result = list(self._forbidden)
result.sort()
return result
- security.declareProtected( ManagePortal, 'addForbiddenTool' )
- def addForbiddenTool( self, tool_id ):
+ security.declareProtected(ManagePortal, 'addForbiddenTool')
+ def addForbiddenTool(self, tool_id):
""" See IToolsetRegistry.
"""
if tool_id in self._forbidden:
return
- if self._required.get( tool_id ) is not None:
- raise ValueError, 'Tool %s is required!' % tool_id
+ if self._required.get(tool_id) is not None:
+ raise ValueError('Tool %s is required!' % tool_id)
- self._forbidden.append( tool_id )
+ self._forbidden.append(tool_id)
- security.declareProtected( ManagePortal, 'listRequiredTools' )
- def listRequiredTools( self ):
+ security.declareProtected(ManagePortal, 'listRequiredTools')
+ def listRequiredTools(self):
""" See IToolsetRegistry.
"""
- result = list( self._required.keys() )
+ result = list(self._required.keys())
result.sort()
return result
- security.declareProtected( ManagePortal, 'getRequiredToolInfo' )
- def getRequiredToolInfo( self, tool_id ):
+ security.declareProtected(ManagePortal, 'getRequiredToolInfo')
+ def getRequiredToolInfo(self, tool_id):
""" See IToolsetRegistry.
"""
- return self._required[ tool_id ]
+ return self._required[tool_id]
- security.declareProtected( ManagePortal, 'listRequiredToolInfo' )
- def listRequiredToolInfo( self ):
+ security.declareProtected(ManagePortal, 'listRequiredToolInfo')
+ def listRequiredToolInfo(self):
""" See IToolsetRegistry.
"""
- return [ self.getRequiredToolInfo( x )
- for x in self.listRequiredTools() ]
+ return [self.getRequiredToolInfo(x)
+ for x in self.listRequiredTools()]
- security.declareProtected( ManagePortal, 'addRequiredTool' )
- def addRequiredTool( self, tool_id, dotted_name ):
+ security.declareProtected(ManagePortal, 'addRequiredTool')
+ def addRequiredTool(self, tool_id, dotted_name):
""" See IToolsetRegistry.
"""
if tool_id in self._forbidden:
- raise ValueError, "Forbidden tool ID: %s" % tool_id
+ raise ValueError("Forbidden tool ID: %s" % tool_id)
- self._required[ tool_id ] = { 'id' : tool_id
- , 'class' : dotted_name
- }
+ self._required[tool_id] = {'id': tool_id, 'class': dotted_name}
- security.declareProtected( ManagePortal, 'generateXML' )
- def generateXML( self ):
+ security.declareProtected(ManagePortal, 'generateXML')
+ def generateXML(self):
""" Pseudo API.
"""
return self._toolsetConfig()
- security.declareProtected( ManagePortal, 'parseXML' )
- def parseXML( self, text, encoding=None ):
+ security.declareProtected(ManagePortal, 'parseXML')
+ def parseXML(self, text, encoding=None):
""" Pseudo-API
"""
- reader = getattr( text, 'read', None )
+ reader = getattr(text, 'read', None)
if reader is not None:
text = reader()
- parser = _ToolsetParser( encoding )
- parseString( text, parser )
+ parser = _ToolsetParser(encoding)
+ parseString(text, parser)
for tool_id in parser._forbidden:
- self.addForbiddenTool( tool_id )
+ self.addForbiddenTool(tool_id)
for tool_id, dotted_name in parser._required.items():
- self.addRequiredTool( tool_id, dotted_name )
+ self.addRequiredTool(tool_id, dotted_name)
- security.declarePrivate( 'clear' )
- def clear( self ):
+ security.declarePrivate('clear')
+ def clear(self):
self._forbidden = []
self._required = {}
@@ -672,92 +665,78 @@
#
# Helper methods.
#
- security.declarePrivate( '_toolsetConfig' )
- _toolsetConfig = PageTemplateFile( 'tscExport.xml'
- , _xmldir
- , __name__='toolsetConfig'
- )
+ security.declarePrivate('_toolsetConfig')
+ _toolsetConfig = PageTemplateFile('tscExport.xml', _xmldir,
+ __name__='toolsetConfig')
-InitializeClass( ToolsetRegistry )
+InitializeClass(ToolsetRegistry)
-class ProfileRegistry( Implicit ):
+class ProfileRegistry(Implicit):
""" Track registered profiles.
"""
implements(IProfileRegistry)
security = ClassSecurityInfo()
- security.setDefaultAccess( 'allow' )
+ security.setDefaultAccess('allow')
- def __init__( self ):
+ def __init__(self):
self._registered = GlobalRegistryStorage(IProfile)
self.clear()
- security.declareProtected( ManagePortal, 'getProfileInfo' )
- def getProfileInfo( self, profile_id, for_=None ):
+ security.declareProtected(ManagePortal, 'getProfileInfo')
+ def getProfileInfo(self, profile_id, for_=None):
""" See IProfileRegistry.
"""
result = self._registered.get(profile_id)
if result is None:
- raise KeyError, profile_id
+ raise KeyError(profile_id)
if for_ is not None:
- if not issubclass( for_, result['for'] ):
- raise KeyError, profile_id
+ if not issubclass(for_, result['for']):
+ raise KeyError(profile_id)
return result.copy()
- security.declareProtected( ManagePortal, 'listProfiles' )
- def listProfiles( self, for_=None ):
+ security.declareProtected(ManagePortal, 'listProfiles')
+ def listProfiles(self, for_=None):
""" See IProfileRegistry.
"""
result = []
for profile_id in self._registered.keys():
- info = self.getProfileInfo( profile_id )
- if for_ is None or issubclass( for_, info['for'] ):
- result.append( profile_id )
- return tuple( result )
+ info = self.getProfileInfo(profile_id)
+ if for_ is None or issubclass(for_, info['for']):
+ result.append(profile_id)
+ return tuple(result)
- security.declareProtected( ManagePortal, 'listProfileInfo' )
- def listProfileInfo( self, for_=None ):
+ security.declareProtected(ManagePortal, 'listProfileInfo')
+ def listProfileInfo(self, for_=None):
""" See IProfileRegistry.
"""
- candidates = [ self.getProfileInfo( id )
- for id in self.listProfiles() ]
- return [ x for x in candidates if for_ is None or x['for'] is None or
- issubclass( for_, x['for'] ) ]
+ candidates = [self.getProfileInfo(id)
+ for id in self.listProfiles()]
+ return [x for x in candidates if for_ is None or x['for'] is None or
+ issubclass(for_, x['for'])]
- security.declareProtected( ManagePortal, 'registerProfile' )
- def registerProfile( self
- , name
- , title
- , description
- , path
- , product=None
- , profile_type=BASE
- , for_=None
- ):
+ security.declareProtected(ManagePortal, 'registerProfile')
+ def registerProfile(self, name, title, description, path, product=None,
+ profile_type=BASE, for_=None):
""" See IProfileRegistry.
"""
profile_id = self._computeProfileId(name, product)
if self._registered.get(profile_id) is not None:
- raise KeyError, 'Duplicate profile ID: %s' % profile_id
+ raise KeyError('Duplicate profile ID: %s' % profile_id)
- info = { 'id' : profile_id
- , 'title' : title
- , 'description' : description
- , 'path' : path
- , 'product' : product
- , 'type': profile_type
- , 'for': for_
- }
+ info = {'id': profile_id, 'title': title, 'description': description,
+ 'path': path, 'product': product, 'type': profile_type,
+ 'for': for_}
metadata = ProfileMetadata(path, product=product)()
# metadata.xml description trumps ZCML description... awkward
- info.update( metadata )
+ info.update(metadata)
self._registered[profile_id] = info
@@ -765,16 +744,16 @@
profile_id = '%s:%s' % (product or 'other', name)
return profile_id
- security.declareProtected( ManagePortal, 'unregisterProfile' )
- def unregisterProfile( self, name, product=None):
+ security.declareProtected(ManagePortal, 'unregisterProfile')
+ def unregisterProfile(self, name, product=None):
profile_id = self._computeProfileId(name, product)
del self._registered[profile_id]
- security.declarePrivate( 'clear' )
- def clear( self ):
+ security.declarePrivate('clear')
+ def clear(self):
self._registered.clear()
-InitializeClass( ProfileRegistry )
+InitializeClass(ProfileRegistry)
_profile_registry = ProfileRegistry()
More information about the checkins
mailing list