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 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):
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)
"""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.")
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)
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(
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 __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()
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)
bodytext = self._htmlsrc % { 'title': self.Title(), 'metatags': hdrtext, 'body': self.EditableBody(), } else: hdrlist = self.getMetadataHeaders() hdrtext = formatRFC822Headers(hdrlist) normalizer = queryUtility(ILinebreakNormalizer) if normalizer is not None: text = normalizer.normalizeOutgoing(self, self.text) else: text = self.text bodytext = '%s\r\n\r\n%s' % (hdrtext, text) return bodytext security.declareProtected(View, 'get_size') def get_size(self): """ Used for FTP and apparently the ZMI now too """ return self._size InitializeClass(Document) DocumentFactory = Factory(Document)
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
def add_chart_factory(config, chart_type, factory_class): factory = Factory(factory_class) config.registry.registerUtility(factory, IFactory, chart_type)
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')