def register_data_manager_factory(test=False):
if not test:
factory = Factory(ModelCatalogDataManager,
"Default Model Catalog Data Manager")
else:
factory = Factory(ModelCatalogTestDataManager,
"Test Model Catalog Data Manager")
getGlobalSiteManager().registerUtility(factory, IFactory,
'ModelCatalogDataManager')
def __init__(self,
callable=None,
title='',
description='',
interfaces=None):
callable = callable if callable is not None else self.default_factory
if callable is None or not _builtin_callable(callable):
raise ValueError("Must provide callable object, not %r" %
(callable, ))
Factory.__init__(self, callable, title or self.default_title,
description or self.default_description, interfaces)
def test_create_content_factory_id(self):
@implementer(IAdding)
class Adding(object):
def __init__(self, test):
self.test = test
def add(self, ob):
self.ob = ob
self.test.assertEqual(
ob.__dict__,
{'args': ("bar", "baz"),
'kw': {'email': '*****@*****.**'},
'_foo': 'foo',
})
return ob
def nextURL(self):
return "."
# register content factory for content factory id lookup
ztapi.provideAdapter(None, IComponentLookup, SiteManagerAdapter)
ztapi.provideUtility(IFactory, Factory(C), name='C')
adding = Adding(self)
self._invoke_add(content_factory='C')
(descriminator, callable, args, kw) = self._context.last_action
factory = AddViewFactory(*args)
request = TestRequest()
view = getMultiAdapter((adding, request), name='addthis')
content = view.create('a',0,abc='def')
self.failUnless(isinstance(content, C))
self.assertEqual(content.args, ('a', 0))
self.assertEqual(content.kw, {'abc':'def'})
def setUp(self):
super(TranslateTest, self).setUp()
# Setup the registries
provideAdapter(HTTPCharsets, (IHTTPRequest, ), IUserPreferredCharsets)
provideUtility(Factory(MessageCatalog), IFactory,
'zope.app.MessageCatalog')
self._domain = domain = TranslationDomain()
domain.domain = 'default'
en_catalog = MessageCatalog('en', 'default')
de_catalog = MessageCatalog('de', 'default')
en_catalog.setMessage('short_greeting', 'Hello!')
de_catalog.setMessage('short_greeting', 'Hallo!')
en_catalog.setMessage('greeting', 'Hello $name, how are you?')
de_catalog.setMessage('greeting', 'Hallo $name, wie geht es Dir?')
domain['en-1'] = en_catalog
domain['de-1'] = de_catalog
self._view = Translate(domain, self._getRequest())
def setUp(self):
super(TestGettextExportImport, self).setUp()
# Setup the negotiator utility
provideUtility(negotiator, INegotiator)
self._domain = TranslationDomain()
self._domain.domain = 'default'
provideUtility(Factory(MessageCatalog), IFactory,
'zope.app.MessageCatalog')
def factory(self, _context, id=None, title="", description=''):
"""Register a zmi factory for this class"""
id = id or self.__id
factoryObj = Factory(self.__class, title, description)
# note factories are all in one pile, utilities and content,
# so addable names must also act as if they were all in the
# same namespace, despite the utilities/content division
utility(_context, IFactory, factoryObj,
permission=PublicPermission, name=id)
def main():
# factory = Factory(FakeDb, 'FakeDb')
factory = Factory(FakeDb)
gsm.registerUtility(factory, IFactory, 'mydb')
# print(factory.getInterfaces())
a = queryUtility(IFactory, 'mydb')()
print('Connection? -> {}'.format(a.getConnection()))
# or
b = createObject('mydb')
print('Created mydb? -> {}'.format(b.getConnection()))
def setUp(self):
# placefulSetup
psetup = PlacefulSetup()
self.sm = psetup.setUp(True, True)
self.rootFolder = psetup.rootFolder
super(TestTranslationDomain, self).setUp()
setUpSiteManagerLookup()
self.sm.registerUtility(self._domain, ITranslationDomain, 'default')
provideUtility(Factory(MessageCatalog), IFactory,
'zope.app.MessageCatalog')
def register(self):
"""
Registering a class as Zope Factory, you can load this factory with a createObject
:return: void
"""
self.__gsm.registerUtility(
Factory(self.__klass, self.__klass.__name__),
IFactory,
self.__klass.__name__.lower()
)
def includeme(config: Configurator):
config.include('.template')
config.include('.viewderiver')
# we dont use this but its useful to remember how to do it
# desc = 'request method template_env'
# disc = ('add-request-method', 'template_env')
# intr = config.introspectable('add-request-method', 'template_env', 'template_env request method',
# 'app request methods')
config.add_request_method(
lambda request: request.registry.getUtility(
pyramid_jinja2.IJinja2Environment, TEMPLATE_ENV_NAME),
'template_env')
# # what is the difference between posting an action versus registering the viwe in the cofnig??\\
# config.action(None, config.add_view, kw=dict(context=RootResource, renderer="main_child.jinja2"))
# # this duplicates code
# root_entry = EntryPoint("root")
# config.registry.registerUtility(root_entry, IEntryPoint, 'root')
root = _get_root(
lambda root: config.registry.registerUtility(root, IResourceRoot))
logger.debug("root is %r", root)
# epj = _get_root().sub_resource('entry_points_json', None)
# config.add_view(entry_points_json, context=type(epj), renderer='json')
# _get_root().sub_resource('entry_points', None)
# config.add_view(entry_point_content, name='content', context=type(_get_root().sub_resource('entry_point', None)),
# renderer='json')
config.include('.entrypoint')
# is this used ??
factory = Factory(Resource, 'resource', 'ResourceFactory', (IResource, ))
config.registry.registerUtility(factory, IFactory, 'resource')
config.registry.registerAdapter(MapperProperty, (IObject, ),
IEntryPointMapperAdapter)
config.include('.views')
# i think we need this default renderer to avoid bugs, right now
renderer_pkg = 'pyramid_jinja2.renderer_factory'
config.add_renderer(None, renderer_pkg)
config.include('.tree')
nav_tree = config.register_tree('navtree')
config.add_subscriber(on_context_found, ContextFound)
config.add_subscriber(on_before_render, BeforeRender)
config.add_subscriber(on_new_request, NewRequest)
config.add_subscriber(on_application_created, ApplicationCreated)
bar = TextLine(title=u'Bar')
baz = TextLine(title=u'Baz')
class Foo(PortalContent, DefaultDublinCoreImpl):
implements(IFoo)
def __init__(self, id, bar='', baz=''):
DefaultDublinCoreImpl.__init__(self)
self.id = id
self.bar = bar
self.baz = baz
FooFactory = Factory(Foo)
def test_suite():
suite = unittest.TestSuite()
s = ZopeTestCase.FunctionalDocFileSuite('form.txt')
s.layer = FunctionalLayer
suite.addTest(s)
suite.addTest(
doctest.DocFileSuite('schema.txt',
optionflags=doctest.NORMALIZE_WHITESPACE))
suite.addTest(
doctest.DocFileSuite('widgets.txt',
optionflags=doctest.NORMALIZE_WHITESPACE
| doctest.ELLIPSIS))
return suite
from zope.interface import implements
from persistent import Persistent
from zope.component.factory import Factory
from sparc.event import IEvent
from sparc.event.event import SparcEvent
class PersistentSparcEvent(SparcEvent, Persistent):
"""A Sparc Entity that can be persisted in a ZODB"""
implements(IEvent)
persistentSparcEventFactory = Factory(PersistentSparcEvent)
except AttributeError:
return self._getOb(criterion_id)
security.declareProtected(AddTopics, 'addSubtopic')
def addSubtopic(self, id):
""" Add a new subtopic.
"""
ti = self.getTypeInfo()
ti.constructInstance(self, id)
return self._getOb(id)
#
# Helper methods
#
security.declarePrivate('_criteria_metatype_ids')
def _criteria_metatype_ids(self):
result = []
for mt in self._criteriaTypes:
result.append(mt.meta_type)
return tuple(result)
InitializeClass(Topic)
TopicFactory = Factory(Topic)
security.declareProtected(View, 'listCreators')
listCreators = DefaultDublinCoreImpl.listCreators.im_func
security.declareProtected(View, 'Creator')
Creator = DefaultDublinCoreImpl.Creator.im_func
#
# 'IContentish' interface method
#
security.declareProtected(View, 'SearchableText')
def SearchableText(self):
"""
SeachableText is used for full text seraches of a portal. It
should return a concatenation of all useful text.
"""
return "%s %s" % (self.title, self.description)
InitializeClass(SkinnedFolder)
SkinnedFolderFactory = Factory(SkinnedFolder)
def addSkinnedFolder( self, id, title='', description='', REQUEST=None ):
"""
"""
sf = SkinnedFolder( id, title )
sf.description = description
self._setObject(id, sf, suppress_events=True)
sf = self._getOb( id )
if REQUEST is not None:
REQUEST['RESPONSE'].redirect( sf.absolute_url() + '/manage_main' )
def Type( self ):
return 'Dummy Content Title'
def __call__(self):
if self.view_id is None:
return DummyContent.inheritedAttribute('__call__')(self)
else:
# view_id control for testing
template = getattr(self, self.view_id)
if getattr(aq_base(template), 'isDocTemp', 0):
return template(self, self.REQUEST, self.REQUEST['RESPONSE'])
else:
return template()
DummyFactory = Factory(DummyContent)
class DummyFactoryDispatcher:
"""
Dummy Product Factory Dispatcher
"""
def __init__( self, folder ):
self._folder = folder
def getId(self):
return 'DummyFactoryDispatcher'
def addFoo( self, id, *args, **kw ):
if getattr(self._folder, '_prefix', None):
def __init__(self, file_path, config):
self.file_path = file_path
self.config = config
def __str__(self):
return "byte file at location {}".format(self.file_path)
def __iter__(self):
with open(self.file_path, 'rb') as stream:
file_ = component.createObject(u'mellon.byte_file_from_stream',
stream, self.config)
for snippet in file_:
yield snippet
mellonByteFileFromFilePathAndConfigFactory = Factory(
MellonByteFileFromFilePathAndConfig)
@interface.implementer(mellon.IUnicodeMellonFile)
class MellonUnicodeFileFromFilePathAndConfig(object):
def __init__(self, file_path, config):
self.file_path = file_path
self.config = config
def __str__(self):
return "Unicode file at location {}".format(self.file_path)
def __iter__(self):
_end = 0
_buffer = collections.deque()
_eof_buffer = collections.deque()
"""Holds all relevant informations for direct debit payment method. This is
a bank account.
"""
implements(IBankAccount)
portal_type = "BankAccount"
account_number = FieldProperty(IBankAccount["account_number"])
bank_identification_code = FieldProperty(
IBankAccount["bank_identification_code"])
bank_name = FieldProperty(IBankAccount["bank_name"])
depositor = FieldProperty(IBankAccount["depositor"])
def Title(self):
"""
"""
return self.bank_name + " - " + self.account_number
def displayInfo(self):
""" returns relevant payment information as dictionary
"""
return (
self.account_number,
self.bank_identification_code,
self.bank_name,
self.depositor,
)
bankAccountFactory = Factory(BankAccount,
title=_(u"Create a new bank account"))
class SimpleDocumentAnnotationAdaptor(object):
"""Adapts Simple Document to be Annotatable."""
implements(IMarginaliaAnnotatableAdaptor)
adapts(ISimpleDocument)
def __init__(self, context):
self.context = context
def getBodyText(self):
"""Returns the annotable text"""
return self.context.description
def isAnnotatable(self):
"""Returns a boolean True"""
return True
def getAnnotatedUrl(self, request=None):
"""Returns the annotated url """
view = getMultiAdapter((self.context, request), name=u'absolute_url')
return view()
from zope.component.factory import Factory
documentFactory = Factory(
SimpleDocument,
title=u"Create a simple document.",
description=u"This factory instantiates a new document.")
str(item.attributes[self.key()]))
yield item
def getById(self, Id):
"""Returns ICachableItem that matches id
Args:
id: String that identifies the item to return whose key matches
"""
# we need to create a new object to insure we don't corrupt the generator count
csvsource = CSVSource(self.source, self.factory, self.key())
try:
for item in csvsource.items():
if Id == item.getId():
return item
except StopIteration:
return None
def first(self):
"""Returns the first ICachableItem in the ICachableSource"""
# we need to create a new object to insure we don't corrupt the generator count
csvsource = CSVSource(self.source, self.factory, self.key())
try:
item = csvsource.items().next()
return item
except StopIteration:
return None
CSVSourceFactory = Factory(CSVSource, 'CSVSourceFactory',
'generates CSVSource objects')
def __new__(self, *args, **kwargs):
db = None
if 'string' in kwargs:
db = config.databaseFromString(kwargs['string'])
if 'file' in kwargs:
db = config.databaseFromFile(kwargs['file'])
if 'url' in kwargs:
db = config.databaseFromURL(kwargs['url'])
if not db:
raise ValueError('unable to obtain ZODB object from arguments')
alsoProvides(db, IZODBDatabase)
return db
zodbDatabaseFactory = Factory(zodbDatabaseFactoryHelper)
class zodbDatabaseFromConfigHelper(object):
config_map = {} # {url: IZODBDatabase}
def __new__(self, xml_config=None):
url = None
if xml_config is None or not len(xml_config):
xml_config = getUtility(IAppElementTreeConfig)
for sparc in xml_config.findall('sparc'):
for db in sparc.findall('db'):
for zodb in db.findall('zodb'):
url = zodb.attrib['url']
if not url:
raise LookupError(
from zope.component.factory import Factory
from zope.interface import implements
from zope.schema.fieldproperty import FieldProperty
from sparc.entity import SparcEntity
from interfaces import IEvent
class SparcEvent(SparcEntity):
implements(IEvent)
def __init__(self, **kwargs):
super(SparcEvent, self).__init__(**kwargs)
self._entities = kwargs['entities'] if 'entities' in kwargs else set()
self.datetime = kwargs['datetime']
datetime = FieldProperty(IEvent['datetime'])
def entities(self):
return iter(self._entities) # pickle-safe
sparcEventFactory = Factory(SparcEvent)
security.declarePrivate('_setOldCacheHeaders')
def _setOldCacheHeaders(self):
# return False to disable this simple caching behaviour
return _OldCacheHeaders(self)
security.declareProtected(View, 'Format')
def Format(self):
""" Dublin Core element - resource format """
return self.content_type
security.declareProtected(ModifyPortalContent, 'setFormat')
def setFormat(self, format):
""" Dublin Core element - resource format """
self.manage_changeProperties(content_type=format)
security.declareProtected(ModifyPortalContent, 'PUT')
def PUT(self, REQUEST, RESPONSE):
""" Handle HTTP (and presumably FTP?) PUT requests """
OFS.Image.Image.PUT(self, REQUEST, RESPONSE)
self.reindexObject()
InitializeClass(Image)
ImageFactory = Factory(Image)
def getRoles(self):
"""Return the list of roles assigned to a user."""
return self.getUser().getRoles()
security.declarePublic('getRolesInContext')
def getRolesInContext(self, object):
"""Return the list of roles assigned to the user,
including local roles assigned in context of
the passed in object."""
return self.getUser().getRolesInContext(object)
security.declarePublic('getDomains')
def getDomains(self):
"""Return the list of domain restrictions for a user"""
return self.getUser().getDomains()
security.declarePublic('has_role')
def has_role(self, roles, object=None):
"""Check to see if a user has a given role or roles."""
return self.getUser().has_role(roles, object)
# There are other parts of the interface but they are
# deprecated for use with CMF applications.
InitializeClass(MemberData)
MemberDataFactory = Factory(MemberData)
def manage_addCMFBTreeFolder(dispatcher, id, title='', REQUEST=None):
"""Adds a new BTreeFolder object with id *id*.
"""
id = str(id)
ob = CMFBTreeFolder(id)
ob.title = str(title)
dispatcher._setObject(id, ob)
ob = dispatcher._getOb(id)
if REQUEST is not None:
REQUEST['RESPONSE'].redirect(ob.absolute_url() + '/manage_main' )
class CMFBTreeFolder(BTreeFolder2Base, PortalFolderBase):
"""BTree folder for CMF sites.
"""
security = ClassSecurityInfo()
def __init__(self, id, title=''):
PortalFolderBase.__init__(self, id, title)
BTreeFolder2Base.__init__(self, id)
def _checkId(self, id, allow_dup=0):
PortalFolderBase._checkId(self, id, allow_dup)
BTreeFolder2Base._checkId(self, id, allow_dup)
InitializeClass(CMFBTreeFolder)
CMFBTreeFolderFactory = Factory(CMFBTreeFolder)
def add_chart_factory(config, chart_type, factory_class):
factory = Factory(factory_class)
config.registry.registerUtility(factory, IFactory, chart_type)
self._v_temp_zing_connector_client = ZingConnectorClient()
client = self._v_temp_zing_connector_client
else:
#
# context is a persistent object. Create/retrieve the client
# from the zodb connection object. We store the client in the zodb
# connection object so we are certain that each zope thread has its own
client = getattr(zodb_conn, 'zing_connector_client', None)
if client is None:
setattr(zodb_conn, 'zing_connector_client',
ZingConnectorClient())
client = zodb_conn.zing_connector_client
return client
def send_facts(self, facts):
return self.client.send_facts(facts)
def send_facts_in_batches(self, facts, batch_size=DEFAULT_BATCH_SIZE):
return self.client.send_facts_in_batches(facts, batch_size)
def send_fact_generator_in_batches(self,
fact_gen,
batch_size=DEFAULT_BATCH_SIZE):
return self.client.send_fact_generator_in_batches(fact_gen, batch_size)
def ping(self):
return self.client.ping()
CLIENT_FACTORY = Factory(ZingConnectorClient)
import zope.interface
import zope.component
from zope.component.factory import Factory
from zope.schema.vocabulary import SimpleVocabulary, SimpleTerm
from zope.schema.interfaces import IVocabularyFactory
from quotationtool.renderer import plaintext, rest, html
from interfaces import IQuotationSourceFactory
htmlQuotationFactory = Factory(html.HTMLSource, html.htmlSourceFactory.title,
html.htmlSourceFactory.description)
plainTextQuotationFactory = Factory(plaintext.PlainText,
plaintext.plainTextFactory.title,
plaintext.plainTextFactory.description)
restQuotationFactory = Factory(
rest.ReST,
rest.restFactory.title,
rest.restFactory.description,
)
def QuotationSourceTypesVocabulary(context):
""" A factory for a vocululary of quotation source types.
"""
terms = []
for name, factory in zope.component.getUtilitiesFor(
IQuotationSourceFactory):
terms.append(SimpleTerm(name, title=factory.title))
return SimpleVocabulary(terms)
container value. If container is a sequence of mappings, then it is
inited to a sequence of length X where X matches to number container
mappings that have key.
Args:
container: Container must either be an iterable mapping, or a
container of iterable mappings.
key: Container mapping key to build sequence from
Raises: KeyError if container is not an iterable mapping, or a container
of iterable mappings.
Returns: IReadSequence provider based on container values for key
"""
try:
for name in mapping.IEnumerableMapping:
getattr(container, name)
#container is a map
container = [container[key]] if key in container else []
except AttributeError:
#container is a sequence of maps
new = []
for map_ in container:
if key in map_:
new.append(map_[key])
container = new
super(SparcConfigSequence, self).__init__(container)
SparcConfigSequenceFactory = Factory(SparcConfigSequence)
manage_options = ( OrderSupport.manage_options +
PortalFolderBase.manage_options[1:] )
security.declareProtected(AddPortalFolders, 'manage_addPortalFolder')
def manage_addPortalFolder(self, id, title='', REQUEST=None):
"""Add a new PortalFolder object with id *id*.
"""
ob = PortalFolder(id, title)
self._setObject(id, ob, suppress_events=True)
if REQUEST is not None:
return self.folder_contents( # XXX: ick!
self, REQUEST, portal_status_message="Folder added")
InitializeClass(PortalFolder)
PortalFolderFactory = Factory(PortalFolder)
manage_addPortalFolder = PortalFolder.manage_addPortalFolder.im_func
class ContentFilter:
"""Represent a predicate against a content object's metadata.
"""
MARKER = []
filterSubject = []
def __init__( self
, Title=MARKER
, Creator=MARKER
, Subject=MARKER
db = self.getParentDatabase()
request = self.REQUEST
form = self.getForm()
if doc is None:
doc = self
return getTemporaryDocument(
db,
form,
request,
doc=doc,
validation_mode=validation_mode
).__of__(db)
InitializeClass(PlominoDocument)
addPlominoDocument = Factory(PlominoDocument)
addPlominoDocument.__name__ = "addPlominoDocument"
def getTemporaryDocument(db, form, REQUEST, doc=None, validation_mode=False):
if hasattr(doc, 'real_id'):
return doc
else:
target = TemporaryDocument(
db,
form,
REQUEST,
real_doc=doc,
validation_mode=validation_mode).__of__(db)
return target
body = REQUEST.get('BODY', '')
try:
self._writeFromPUT( body )
RESPONSE.setStatus(204)
return RESPONSE
except ResourceLockedError, msg:
transaction.abort()
RESPONSE.setStatus(423)
return RESPONSE
security.declareProtected(View, 'manage_FTPget')
def manage_FTPget(self):
"""
Get the link as text for WebDAV src / FTP download.
"""
hdrlist = self.getMetadataHeaders()
hdrtext = formatRFC822Headers( hdrlist )
bodytext = '%s\n\n%s' % ( hdrtext, self.getRemoteUrl() )
return bodytext
security.declareProtected(View, 'get_size')
def get_size( self ):
""" Used for FTP and apparently the ZMI now too.
"""
return len(self.manage_FTPget())
InitializeClass(Link)
LinkFactory = Factory(Link)