def test_factory_no_location(self):

        getAnnotation = factory(Target)

        context = Context()
        target = getAnnotation(context)

        # Several things have happened now.
        # First, we have an annotation, derived from
        # our class name
        key = 'zope.annotation.tests.test_factory.Target'
        self.assertEqual([key],
                         list(context))

        # Second, a target object is stored at that location.
        self.assertEqual(type(context[key]), Target)

        # Third, the returned object is an ILocation, rooted at the
        # parent and having the given name.
        self.assertTrue(ILocation.providedBy(target))
        self.assertIs(target.__parent__, context)
        self.assertEqual(target.__name__, key)

        # But it's a proxy.
        self.assertNotEqual(type(target), Target)
        self.assertTrue(ITarget.providedBy(target))

def note_factory(klass, key):
    """\
    Named Annotation Factory maker specific for PMR2 annotations
    """

    key = PREFIX + key
    return factory(klass, key)

    def test_factory_location(self):
        # Given an object that is a location,
        # it is not proxied
        @interface.implementer(ILocation)
        class LocatedTarget(Target):
            __name__ = None
            __parent__ = None

        getAnnotation = factory(LocatedTarget)

        context = Context()
        target = getAnnotation(context)

        key = 'zope.annotation.tests.test_factory.LocatedTarget'
        self.assertEqual([key],
                         list(context))

        # Second, a target object is stored at that location.
        self.assertEqual(type(context[key]), LocatedTarget)

        # Third, the returned object is an ILocation, rooted at the
        # parent and having the given name.
        self.assertTrue(ILocation.providedBy(target))
        self.assertIs(target.__parent__, context)
        self.assertEqual(target.__name__, key)

        # And it's not a proxy.
        self.assertEqual(type(target), LocatedTarget)
        self.assertTrue(ITarget.providedBy(target))
        self.assertIs(target, context[key])

def settings_factory(klass, name, title=None, fields=None):
    key = PREFIX + name
    result = factory(klass, key)
    result.name = result.title = name
    if title is not None:
        result.title = title
    result.fields = fields
    return result

    def test_factory_with_key(self):

        key = 'testkey'
        getAnnotation = factory(Target, key)

        context = Context()
        getAnnotation(context)

        self.assertEqual([key],
                         list(context))

        # Second, a target object is stored at that location.
        self.assertEqual(type(context[key]), Target)

from plone.memoize.ram import global_cache
from plone.app.layout.navigation.defaultpage import isDefaultPage
from Solgema.RichMenu.interfaces import ISolgemaRichMenuAttributes, ISolgemaRichMenuMarker
from Solgema.RichMenu.config import _
LOG = logging.getLogger('Solgema.RichMenu')

class SolgemaRichMenuAttributesAdapter(Persistent):

    implements(ISolgemaRichMenuAttributes)
    component.adapts(interface.Interface)
    def __init__(self):
        for iface in list(directlyProvidedBy(self)):
            for field in [iface.get(name) for name in iface.names() if schema.interfaces.IField.providedBy(iface.get(name))]:
                setattr(self, field.__name__, field.default)

SolgemaRichMenuAttributes = factory(SolgemaRichMenuAttributesAdapter)

class z3cManageSolgemaRichMenuAttributes(form.EditForm):
    
    label = _('Rich Menu parameters')

    @property
    def fields(self):
        fields = field.Fields(ISolgemaRichMenuAttributes)
        portal_quickinstaller = getToolByName(self.context, 'portal_quickinstaller')
        if has_p5 and has_rel and portal_quickinstaller.isProductInstalled('plone.app.widgets'):
            fields['section_menu_item'].widgetFactory[INPUT_MODE] = RelatedItemsFieldWidget
        elif not has_p5 and not has_rel and has_ctree:
            fields['section_menu_item'].widgetFactory[INPUT_MODE] = ContentTreeFieldWidget
        return fields
    

from zope.annotation.interfaces import IAttributeAnnotatable
from zope.annotation import factory
from zope import component
from zope import interface
from zope import schema

from collective.rcse.settings import getDefaultSettings


class ISettings(interface.Interface):
    settings = schema.Dict(
        title=u"Settings",
        key_type=schema.ASCIILine(),
        value_type=schema.ASCIILine()
    )


class Settings(object):
    interface.implements(ISettings)
    component.adapts(IAttributeAnnotatable)

    def __init__(self):
        self.settings = getDefaultSettings()


SettingsFactory = factory(Settings)

        email_list = self._user_email_lists.get(login, ())
        if not email_list:
            return

        if not emails:
            # remove all user's email addresses.
            emails = list(email_list)

        for email in emails:
            try:
                self._email_to_login.pop(email, None)
                email_list.remove(email)
            except ValueError:
                pass

    def get_emails_for(self, login):
        """
        Return all emails for this login.
        """

        return sorted(self._user_email_lists.get(login, []))

    def get_login_for(self, email):
        """
        Return the login for this email address.
        """

        return self._email_to_login.get(email, None)

EmailManagerFactory = factory(EmailManager)

# 2010 Ilshad Khabibullin <[email protected]>

from persistent import Persistent
from zope.interface import implements
from zope.component import adapts
from zope.component import getUtility
from zope.annotation import factory
from zope.schema.fieldproperty import FieldProperty
from zope.authentication.interfaces import IAuthentication
from zope.authentication.interfaces import PrincipalLookupError
from interfaces import IResponsibility
from interfaces import IIssue

class Responsibility(Persistent):
    implements(IResponsibility)
    adapts(IIssue)

    responsible = FieldProperty(IResponsibility["responsible"])

    def get_principal(self):
        auth = getUtility(IAuthentication)
        if self.responsible is None:
            return None
        try:
            return auth.getPrincipal(self.responsible)
        except PrincipalLookupError:
            return None
    
annotation_factory = factory(Responsibility)

class IRecaptchaInfo(Interface):
    error = schema.TextLine()
    verified = schema.Bool()


class RecaptchaInfoAnnotation(object):
    implements(IRecaptchaInfo)
    adapts(IBrowserRequest)

    def __init__(self):
        self.error = None
        self.verified = False

RecaptchaInfo = factory(RecaptchaInfoAnnotation)


class RecaptchaView(BrowserView):

    def __init__(self, context, request):
        self.context = context
        self.request = request
        self.settings = getRecaptchaSettings()

    def image_tag(self):
        portal_state = queryMultiAdapter(
            (self.context, self.request), name=u'plone_portal_state')
        if portal_state is not None:
            lang = portal_state.language()[:2]
        else:

        """Make the adapter penetratable for the vocabulary to find the cat"""
        return getToolByName(getSite(), 'portal_catalog')

    @property
    def portal_url(self):
        """Make the adapter penetratable for the vocabulary to find the cat"""
        return getToolByName(getSite(), 'portal_url')

    urls = []


class LinkList(LinkListBase):
    implements(ILinkList, ILinkListDocument)
    adapts(IATDocument)

linklist_adapter_document = factory(LinkList)


class LinkListFolder(LinkListBase):
    implements(ILinkList, ILinkListFolder)
    adapts(IATFolder)

linklist_adapter_folder = factory(LinkListFolder)


class LinkCollectionForm(form.PageEditForm):
    form_fields = form.Fields(ILinkList)
    label = u"Add Content Objects to point to"
    form_fields['urls'].custom_widget = UberMultiSelectionWidget

    @form.action(_("Apply"))

    def add(self, subscription):
        self.subscriptions[self._next_id] = subscription
        self._next_id += 1

    def remove(self, n):
        del self.subscriptions[n]

    def list_with_keys(self):
        for n, subscription in self.subscriptions.iteritems():
            yield n, subscription

    def __iter__(self):
        for subscription in self.subscriptions.itervalues():
            yield subscription

subscription_container_factory = annotation.factory(SubscriptionContainer)

class AccountSubscription(object):
    interface.implements(ISubscription)

    def __init__(self, user_id, notif_type, lang):
        self.user_id = user_id
        self.lang = lang
        self.notif_type = notif_type

    def check_permission(self, obj):
        acl_users = obj.getSite().getAuthenticationTool()
        user = acl_users.get_user_with_userid(self.user_id)

        if user is None:
            return False

                                'location is not a workspace container')
            else:
                raise TypeError('the content returned is not a user workspace '
                                'container')
        return obj

    def getExposureContainer(self):
        return self.siteManagerUnrestrictedTraverse(
            self.default_exposure_subpath)

    def siteManagerUnrestrictedTraverse(self, subpath):
        sm = getSiteManager(self)
        path = '../%s' % subpath
        return sm.unrestrictedTraverse(str(path), None)

PMR2GlobalSettings = factory(PMR2GlobalSettingsAnnotation)


def _make_default_path():
    # While ${SOFTWARE_HOME} is typically standard "default" location
    # for application specific files, this product is normally installed 
    # via buildout, hence this directory will be recreated on each 
    # reinstall.  This basically makes it a bad choice for storing any
    # persistent information as they will be unlinked every upgrade.
    # The ${CLIENT_HOME} is more stable, however it might not exist, so
    # we will have fallback.

    suffix = 'pmr2'
    envvar = ['CLIENT_HOME', 'SOFTWARE_HOME']

    for v in envvar:

import zope.interface
import zope.component
from zope.schema import fieldproperty
from zope.annotation.interfaces import IAttributeAnnotatable
from zope.annotation import factory
from zope.container.contained import Contained
from persistent import Persistent

from pmr2.virtuoso.interfaces import IWorkspaceRDFInfo


@zope.component.adapter(IAttributeAnnotatable)
@zope.interface.implementer(IWorkspaceRDFInfo)
class WorkspaceRDFInfo(Persistent, Contained):

    paths = fieldproperty.FieldProperty(IWorkspaceRDFInfo['paths'])


WorkspaceRDFInfoFactory = factory(WorkspaceRDFInfo)

        super(StagingRelationValue, self).__init__(to_id)
        self.staging_properties = PersistentDict()
        # remember the creator
        portal = getUtility(ISiteRoot)
        mstool = getToolByName(portal, 'portal_membership')
        self.creator = mstool.getAuthenticatedMember().getId()


class Storage(Persistent):
    implements(IWCAnnotator)
    adapts(IDexterityContent)

    def __init__(self):
        super(Storage, self).__init__()
        self._data = None

    def set_relation(self, value):
        # dewrap __parent__ attribute,
        # CMFEdition cannot pickle wrapped objects
        value.__parent__ = aq_base(value.__parent__)
        self._data = value

    def get_relation(self):
        return self._data

    def delete(self):
        self._data = None


WCAnnotator = factory(Storage)

import orm

from schema import metadata

from domain import User, Minister
from domain import (GroupMembership, Group, Government, Parliament,
    PoliticalParty, Ministry, Committee, CommitteeType, CommitteeTypeStatus
)
from domain import (GroupSitting, GroupSittingType, GroupSittingAttendance,
    AttendanceType
)
from domain import ParliamentSession, PoliticalGroup
from domain import (Question, QuestionVersion, QuestionChange, QuestionType, 
    ResponseType
)
from domain import Motion, MotionVersion, MotionChange
from domain import Bill, BillVersion, BillChange, BillType
from domain import Constituency, Parliament
from domain import Country, Region, Province
from domain import MemberOfParliament, MemberElectionType
from domain import TitleType, MemberTitle
from domain import ItemSchedule

from domain import AddressType, GroupAddress, UserAddress, PostalAddressType

from zope.annotation import factory
from zope import component
from roles import SubRoleAnnotations
component.provideAdapter(factory(SubRoleAnnotations))

    )


class FavoritingStorage(object):
    interface.implements(IFavoritingStorage)
    component.adapts(IAttributeAnnotatable)

    def __init__(self):
        """
        Note that the annotation implementation does not expect any arguments
        to its `__init__`. Otherwise it's basically an adapter.
        """
        self.favoritedby = []


FavoritingStorageFactory = factory(FavoritingStorage)


class FavoritingManager(BrowserView):
    """implementation of IFavoriting using annotation + portal_catalog"""
    interface.implements(IFavoritingManager)

    def __init__(self, context, request):
        self.context = context
        self.request = request
        self.userid = None
        self.membership = None
        self.catalog = None
        self.favorites = []
        self.storage = None

from cellml.theme.vocab import get_layout


class LayoutSettings(Persistent):
    """
    Maps between the two thing,
    """

    interface.implements(ILayoutSettings)
    component.adapts(interface.Interface)

    layout = fieldproperty.FieldProperty(ILayoutSettings['layout'])

    def get_layout(self, sl, sr):
        """
        Return the layout name.
        """

        leftcolumn, rightcolumn, bothcolumns = get_layout(self.layout)

        # a simple truth table to figure this out.
        return {
            (False, False): u'layoutZero',
            (True, False): leftcolumn,
            (False, True): rightcolumn,
            (True, True): bothcolumns,
        }[(sl, sr)]


LayoutSettingsFactory = factory(LayoutSettings)

from zope.interface import implements
from zope.annotation import factory

from tackle.interfaces import ISubscription, ISubscribable
from tackle.profile import get_profile
from tackle.smtp import send_mail

class Subscription(Persistent):
    implements(ISubscription)
    adapts(ISubscribable)

    def __init__(self):
        self.subscribers = OOTreeSet()

    def subscribe(self, principal_id):
        self.subscribers.insert(principal_id)

    def unsubscribe(self, principal_id):
        self.subscribers.remove(principal_id)

    def send(self, message, subject):
        for pid in self.subscribers.keys():
            profile = get_profile(pid, "basic")
            send_mail(message, subject, profile.email)

annotation_factory = factory(Subscription)

def subscribe(ob, event):
    subscription = ISubscription(event.context)
    subscription.send(event.message)

# -*- coding: utf-8 --
import logging
from persistent import Persistent
from zope import component, schema
from zope.interface import implementer, provider
from zope.component import adapter
from zope.annotation import factory
from Products.CMFCore.interfaces import ISiteRoot
import interfaces

LOG = logging.getLogger(__name__)

@implementer(interfaces.IOdooPasSettings)
@adapter(ISiteRoot)
class OdooPasSettingsAdapter(Persistent):
  
    def __init__(self, **kwargs):
        iface = interfaces.IOdooPasSettings
        for field in [iface.get(name) for name in iface.names() if schema.interfaces.IField.providedBy(iface.get(name))]:
            setattr(self, field.__name__, kwargs.get(field.__name__, field.default))

OdooPasSettings = factory(OdooPasSettingsAdapter)