def test_import_c_accel(self): import sys old_pp = FUT.PURE_PYTHON assert not hasattr(sys, 'import_c_accel') sys.import_c_accel = self try: FUT.PURE_PYTHON = False d = {'__name__': 'foo', 'import_c_accel': self} FUT.import_c_accel(d, 'sys') assert_that(d, has_key('modules')) assert_that(d, has_entry('__name__', 'sys')) self.assertNotIn('import_c_accel', d) FUT.import_c_accel(d, 'sys') finally: FUT.PURE_PYTHON = old_pp del sys.import_c_accel
FutureWarning ) if policy is NotGiven: if policy_name is not NotGiven: policy = getUtility(IExternalizationPolicy, policy_name) else: policy = manager_top[2] memos = manager_top[1] if memos is None: # Don't live beyond this dynamic function call memos = defaultdict(dict) state = _ExternalizationState(memos, name, catch_components, catch_component_action, request, default_non_externalizable_replacer, decorate, useCache, decorate_callback, policy) _manager_push((name, memos, policy)) try: return _to_external_object_state(obj, state, top_level=True) finally: _manager_pop() from nti.externalization._compat import import_c_accel # pylint:disable=wrong-import-position,wrong-import-order import_c_accel(globals(), 'nti.externalization.externalization._externalizer')
# XXX: We have a public user of this in nti.ntiids.oids. We need # to document this and probably move it to a different module, or # provide a cleaner simpler replacement. for x in fields: value = getattr(self, x, None) if value is None: continue if converter is not None: value = converter(value) if value is not None: result[ext_name] = value return value # Nothing. Can we adapt it? if sup_iface is not None and sup_fields: self = sup_iface(self, None) if self is not None: return choose_field(result, self, ext_name, converter=sup_converter, fields=sup_fields) # Falling off the end: return None return None from nti.externalization._compat import import_c_accel # pylint:disable=wrong-import-position,wrong-import-order import_c_accel(globals(), 'nti.externalization.externalization._fields')
Create and send an `~.ObjectModifiedFromExternalEvent` for *containedObject* using `zope.event.notify`. The *containedObject* is the subject of the event. The *externalObject* is the dictionary of data that was used to update the *containedObject*. *external_keys* is list of keys from *externalObject* that actually changed *containedObject*. If this is not given, we assume that all keys in *externalObject* were changed. Note that these should to correspond to the interface fields of interfaces that the *containedObject* implements in order to properly be able to create and populate the `zope.lifecycleevent` `~zope.lifecycleevent.IAttributes`. *updater*, if given, is the `~nti.externalization.interfaces.IInternalObjectUpdater` instance that was used to handle the updates. If this object implements an ``_ext_adjust_modified_event`` method, it will be called to adjust (and return) the event object that will be notified. *kwargs* are the keyword arguments passed to the event constructor. :return: The event object that was notified. """ return _notifyModified(containedObject, externalObject, updater, external_keys, kwargs) from nti.externalization._compat import import_c_accel # pylint:disable=wrong-import-position,wrong-import-order import_c_accel(globals(), 'nti.externalization.internalization._events')
externalObject[k] = _update_from_external_object( new_obj, v, args) if _obj_has_usable_updateFromExternalObject(containedObject): # legacy support. The __ext_ignore_updateFromExternalObject__ # allows a transition to an adapter without changing # existing callers and without triggering infinite recursion updater = containedObject else: # It's possible for INamedExternalizedObjectFactoryFinder and # IInternalObjectUpdater to be registered at two different levels # of specificity, so we need to look up IInternalObjectUpdater, # not test if it's provided by what we already have. if args.require_updater and not isinstance(containedObject, dict): updater = IInternalObjectUpdater(containedObject) else: updater = IInternalObjectUpdater(containedObject, None) if updater is not None: notify_event( ObjectWillUpdateFromExternalEvent(containedObject, externalObject, args.root)) _invoke_updater(containedObject, externalObject, updater, external_keys, args) return containedObject from nti.externalization._compat import import_c_accel # pylint:disable=wrong-import-position,wrong-import-order import_c_accel(globals(), 'nti.externalization.internalization._updater')
attrs[key] = cache cache_instances.add(cache) return cache def cache_for(externalizer, ext_self): # type: (object, object) -> InterfaceCache return cache_for_key_in_providedBy(type(externalizer), providedBy(ext_self)) def _cache_cleanUp(instances): # XXX: On PyPy (3 only?) ``list(instances)`` has been # seen to raise "RuntimeError: set changed size during iteration." # We should probably try to run a gc.collect() before iterating it. for x in list(instances): x.__init__() try: from zope.testing import cleanup except ImportError: # pragma: no cover pass else: cleanup.addCleanUp(_cache_cleanUp, args=(cache_instances, )) # pylint:disable=wrong-import-position from nti.externalization._compat import import_c_accel import_c_accel(globals(), 'nti.externalization.__interface_cache')
:param bool case_sensitive: If False (the default), then the results will have each factory twice, once with its found name, and once with its name lower cased. :return: An iterable of found (name, factory). """ # It's not totally clear why this is in legacy_factories; # it's used from modern stuff like ext:registerAutoPackageIO result = [] mod_name = module.__name__ # If we're dealing with a namespace object, such as what # AutoPackaegIO produces, it may represent types from many modules # on purpose. OTOH, if we get here via a string that was supposed # to be a module, then we need to respect that and ignore imports. # This is complicated by the fact that zope.deprecation puts DeprecationProxy # objects into sys.modules, but they appear to handle that correctly accept_any_module = not isinstance(module, types.ModuleType) for name, value in sorted(vars(module).items()): if (callable(value) and getattr(value, '__external_can_create__', False) and (accept_any_module or getattr(value, '__module__', NotGiven) == mod_name)): result.append((name, value)) if not case_sensitive and name.lower() != name: result.append((name.lower(), value)) return result # pylint:disable=wrong-import-position,wrong-import-order from nti.externalization._compat import import_c_accel import_c_accel(globals(), 'nti.externalization.internalization._legacy_factories')
ancestor = object for ancestor in cls.mro(): if '__new__' in ancestor.__dict__: break if isinstance(ancestor, SingletonMetaclass) and ancestor is not cls: ctor = ancestor._new_instance else: ctor = cls.__new__ cls._new_instance = staticmethod(ctor) the_instance = ctor(cls) cls.__new__ = staticmethod(lambda *args: the_instance) return cls SingletonDecorator = SingletonMetaclass # BWC Singleton = SingletonMetaclass( 'Singleton', (object, ), { '__doc__': "A base class for singletons. " "Can be more convenient than a metaclass for Python2/Python3 compatibility." }) from nti.externalization._compat import import_c_accel import_c_accel(globals(), 'nti.externalization._singleton')
# In that case, we are not suitable for use with this object. # TODO: This algorithm can and should be better in some cases, following the # C3 algorithm that __sro__ derivation itself uses. for iface in self._ext_schemas_to_consider(ext_self): if iface is most_derived: # Support interfaces that have their __module__ changed # dynamically (e.g., test_benchmarks) continue if not most_derived.isOrExtends(iface): raise TypeError( "Most derived interface %s does not extend %s; non-tree interface structure. " "Searching module %s and considered %s on object %s of class %s and type %s" % (most_derived, iface, self._ext_search_module, list(self._ext_schemas_to_consider(ext_self)), ext_self, ext_self.__class__, type(ext_self))) return most_derived def _ext_schemas_to_consider(self, ext_self): search_module_name = self._ext_search_module.__name__ return [ x for x in interface.providedBy(ext_self) if x.__module__ == search_module_name and not x.queryDirectTaggedValue('_ext_is_marker_interface') ] # pylint:disable=wrong-import-position,wrong-import-order from nti.externalization._compat import import_c_accel import_c_accel(globals(), 'nti.externalization._datastructures')
Instances are immutable. This class must not be subclassed; as such, there is no interface for it, merely the class itself. """ __slots__ = ('use_iso8601_for_unix_timestamp', ) def __init__(self, use_iso8601_for_unix_timestamp=False): #: Should unix timestamp fields be output as their numeric value, #: or be converted into an ISO 8601 timestamp string? By default, #: the numeric value is output. This is known to specifically apply #: to "Created Time" and "Last Modified." self.use_iso8601_for_unix_timestamp = use_iso8601_for_unix_timestamp def __repr__(self): # pragma: no cover return "ExternalizationPolicy(use_iso8601_for_unix_timestamp=%s)" % ( self.use_iso8601_for_unix_timestamp) #: The default externalization policy. DEFAULT_EXTERNALIZATION_POLICY = ExternalizationPolicy() def get_default_externalization_policy(): return DEFAULT_EXTERNALIZATION_POLICY from nti.externalization._compat import import_c_accel # pylint:disable=wrong-import-position import_c_accel(globals(), 'nti.externalization.__base_interfaces')
return internal_to_standard_external_dictionary( self, mergeFrom, decorate, request, decorate_callback, policy, ) def to_minimal_standard_external_dictionary(self, mergeFrom=None): """ Does no decoration. Useful for non-'object' types. *self* should have a *mime_type* field. """ result = make_external_dict() if mergeFrom is not None: result.update_from_other(mergeFrom) if StandardExternalFields.CLASS not in result: get_class(self, result) mime_type = getattr(self, 'mimeType', None) or getattr( self, 'mime_type', None) if mime_type is not None and mime_type: result[StandardExternalFields.MIMETYPE] = mime_type return result from nti.externalization._compat import import_c_accel # pylint:disable=wrong-import-position,wrong-import-order import_c_accel(globals(), 'nti.externalization.externalization._dictionary')
request = get_current_request() if request is not None: # Request specific decorating, if given, is more specific than plain object # decorating, so it gets to go last. for decorator in subscribers((original_object, request), decorate_interface): meth = getattr(decorator, decorate_meth_name) meth(original_object, external_object) elif call_if_not_decorate is not NotGiven and call_if_not_decorate is not None: # XXX: This makes no sense. What is this argument even for? call_if_not_decorate(original_object, external_object) return external_object def decorate_external_mapping( original_object, external_object, registry, # legacy, ignored. pylint:disable=unused-argument request): # A convenience API exposed to Python in __init__.py return decorate_external_object(True, None, IExternalStandardDictionaryDecorator, 'decorateExternalMapping', original_object, external_object, None, request) from nti.externalization._compat import import_c_accel # pylint:disable=wrong-import-position,wrong-import-order import_c_accel(globals(), 'nti.externalization.externalization._decorate')