diff options
Diffstat (limited to 'python/gevent/local.py')
| -rw-r--r-- | python/gevent/local.py | 605 |
1 files changed, 0 insertions, 605 deletions
diff --git a/python/gevent/local.py b/python/gevent/local.py deleted file mode 100644 index f29bb23..0000000 --- a/python/gevent/local.py +++ /dev/null @@ -1,605 +0,0 @@ -# cython: auto_pickle=False,embedsignature=True,always_allow_keywords=False -""" -Greenlet-local objects. - -This module is based on `_threading_local.py`__ from the standard -library of Python 3.4. - -__ https://github.com/python/cpython/blob/3.4/Lib/_threading_local.py - -Greenlet-local objects support the management of greenlet-local data. -If you have data that you want to be local to a greenlet, simply create -a greenlet-local object and use its attributes: - - >>> mydata = local() - >>> mydata.number = 42 - >>> mydata.number - 42 - -You can also access the local-object's dictionary: - - >>> mydata.__dict__ - {'number': 42} - >>> mydata.__dict__.setdefault('widgets', []) - [] - >>> mydata.widgets - [] - -What's important about greenlet-local objects is that their data are -local to a greenlet. If we access the data in a different greenlet: - - >>> log = [] - >>> def f(): - ... items = list(mydata.__dict__.items()) - ... items.sort() - ... log.append(items) - ... mydata.number = 11 - ... log.append(mydata.number) - >>> greenlet = gevent.spawn(f) - >>> greenlet.join() - >>> log - [[], 11] - -we get different data. Furthermore, changes made in the other greenlet -don't affect data seen in this greenlet: - - >>> mydata.number - 42 - -Of course, values you get from a local object, including a __dict__ -attribute, are for whatever greenlet was current at the time the -attribute was read. For that reason, you generally don't want to save -these values across greenlets, as they apply only to the greenlet they -came from. - -You can create custom local objects by subclassing the local class: - - >>> class MyLocal(local): - ... number = 2 - ... initialized = False - ... def __init__(self, **kw): - ... if self.initialized: - ... raise SystemError('__init__ called too many times') - ... self.initialized = True - ... self.__dict__.update(kw) - ... def squared(self): - ... return self.number ** 2 - -This can be useful to support default values, methods and -initialization. Note that if you define an __init__ method, it will be -called each time the local object is used in a separate greenlet. This -is necessary to initialize each greenlet's dictionary. - -Now if we create a local object: - - >>> mydata = MyLocal(color='red') - -Now we have a default number: - - >>> mydata.number - 2 - -an initial color: - - >>> mydata.color - 'red' - >>> del mydata.color - -And a method that operates on the data: - - >>> mydata.squared() - 4 - -As before, we can access the data in a separate greenlet: - - >>> log = [] - >>> greenlet = gevent.spawn(f) - >>> greenlet.join() - >>> log - [[('color', 'red'), ('initialized', True)], 11] - -without affecting this greenlet's data: - - >>> mydata.number - 2 - >>> mydata.color - Traceback (most recent call last): - ... - AttributeError: 'MyLocal' object has no attribute 'color' - -Note that subclasses can define slots, but they are not greenlet -local. They are shared across greenlets:: - - >>> class MyLocal(local): - ... __slots__ = 'number' - - >>> mydata = MyLocal() - >>> mydata.number = 42 - >>> mydata.color = 'red' - -So, the separate greenlet: - - >>> greenlet = gevent.spawn(f) - >>> greenlet.join() - -affects what we see: - - >>> mydata.number - 11 - ->>> del mydata - -.. versionchanged:: 1.1a2 - Update the implementation to match Python 3.4 instead of Python 2.5. - This results in locals being eligible for garbage collection as soon - as their greenlet exits. - -.. versionchanged:: 1.2.3 - Use a weak-reference to clear the greenlet link we establish in case - the local object dies before the greenlet does. - -.. versionchanged:: 1.3a1 - Implement the methods for attribute access directly, handling - descriptors directly here. This allows removing the use of a lock - and facilitates greatly improved performance. - -.. versionchanged:: 1.3a1 - The ``__init__`` method of subclasses of ``local`` is no longer - called with a lock held. CPython does not use such a lock in its - native implementation. This could potentially show as a difference - if code that uses multiple dependent attributes in ``__slots__`` - (which are shared across all greenlets) switches during ``__init__``. - -""" -from __future__ import print_function - -from copy import copy -from weakref import ref - - -locals()['getcurrent'] = __import__('greenlet').getcurrent -locals()['greenlet_init'] = lambda: None - -__all__ = [ - "local", -] - -# The key used in the Thread objects' attribute dicts. -# We keep it a string for speed but make it unlikely to clash with -# a "real" attribute. -key_prefix = '_gevent_local_localimpl_' - -# The overall structure is as follows: -# For each local() object: -# greenlet.__dict__[key_prefix + str(id(local))] -# => _localimpl.dicts[id(greenlet)] => (ref(greenlet), {}) - -# That final tuple is actually a localimpl_dict_entry object. - -def all_local_dicts_for_greenlet(greenlet): - """ - Internal debug helper for getting the local values associated - with a greenlet. This is subject to change or removal at any time. - - :return: A list of ((type, id), {}) pairs, where the first element - is the type and id of the local object and the second object is its - instance dictionary, as seen from this greenlet. - - .. versionadded:: 1.3a2 - """ - - result = [] - id_greenlet = id(greenlet) - greenlet_dict = greenlet.__dict__ - for k, v in greenlet_dict.items(): - if not k.startswith(key_prefix): - continue - local_impl = v() - if local_impl is None: - continue - entry = local_impl.dicts.get(id_greenlet) - if entry is None: - # Not yet used in this greenlet. - continue - assert entry.wrgreenlet() is greenlet - result.append((local_impl.localtypeid, entry.localdict)) - - return result - - -class _wrefdict(dict): - """A dict that can be weak referenced""" - -class _greenlet_deleted(object): - """ - A weakref callback for when the greenlet - is deleted. - - If the greenlet is a `gevent.greenlet.Greenlet` and - supplies ``rawlink``, that will be used instead of a - weakref. - """ - __slots__ = ('idt', 'wrdicts') - - def __init__(self, idt, wrdicts): - self.idt = idt - self.wrdicts = wrdicts - - def __call__(self, _unused): - dicts = self.wrdicts() - if dicts: - dicts.pop(self.idt, None) - -class _local_deleted(object): - __slots__ = ('key', 'wrthread', 'greenlet_deleted') - - def __init__(self, key, wrthread, greenlet_deleted): - self.key = key - self.wrthread = wrthread - self.greenlet_deleted = greenlet_deleted - - def __call__(self, _unused): - thread = self.wrthread() - if thread is not None: - try: - unlink = thread.unlink - except AttributeError: - pass - else: - unlink(self.greenlet_deleted) - del thread.__dict__[self.key] - -class _localimpl(object): - """A class managing thread-local dicts""" - __slots__ = ('key', 'dicts', - 'localargs', 'localkwargs', - 'localtypeid', - '__weakref__',) - - def __init__(self, args, kwargs, local_type, id_local): - self.key = key_prefix + str(id(self)) - # { id(greenlet) -> _localimpl_dict_entry(ref(greenlet), greenlet-local dict) } - self.dicts = _wrefdict() - self.localargs = args - self.localkwargs = kwargs - self.localtypeid = local_type, id_local - - # We need to create the thread dict in anticipation of - # __init__ being called, to make sure we don't call it - # again ourselves. MUST do this before setting any attributes. - greenlet = getcurrent() # pylint:disable=undefined-variable - _localimpl_create_dict(self, greenlet, id(greenlet)) - -class _localimpl_dict_entry(object): - """ - The object that goes in the ``dicts`` of ``_localimpl`` - object for each thread. - """ - # This is a class, not just a tuple, so that cython can optimize - # attribute access - __slots__ = ('wrgreenlet', 'localdict') - - def __init__(self, wrgreenlet, localdict): - self.wrgreenlet = wrgreenlet - self.localdict = localdict - -# We use functions instead of methods so that they can be cdef'd in -# local.pxd; if they were cdef'd as methods, they would cause -# the creation of a pointer and a vtable. This happens -# even if we declare the class @cython.final. functions thus save memory overhead -# (but not pointer chasing overhead; the vtable isn't used when we declare -# the class final). - - -def _localimpl_create_dict(self, greenlet, id_greenlet): - """Create a new dict for the current thread, and return it.""" - localdict = {} - key = self.key - - wrdicts = ref(self.dicts) - - # When the greenlet is deleted, remove the local dict. - # Note that this is suboptimal if the greenlet object gets - # caught in a reference loop. We would like to be called - # as soon as the OS-level greenlet ends instead. - - # If we are working with a gevent.greenlet.Greenlet, we - # can pro-actively clear out with a link, avoiding the - # issue described above. Use rawlink to avoid spawning any - # more greenlets. - greenlet_deleted = _greenlet_deleted(id_greenlet, wrdicts) - - rawlink = getattr(greenlet, 'rawlink', None) - if rawlink is not None: - rawlink(greenlet_deleted) - wrthread = ref(greenlet) - else: - wrthread = ref(greenlet, greenlet_deleted) - - - # When the localimpl is deleted, remove the thread attribute. - local_deleted = _local_deleted(key, wrthread, greenlet_deleted) - - - wrlocal = ref(self, local_deleted) - greenlet.__dict__[key] = wrlocal - - self.dicts[id_greenlet] = _localimpl_dict_entry(wrthread, localdict) - return localdict - - -_marker = object() - -def _local_get_dict(self): - impl = self._local__impl - # Cython can optimize dict[], but not dict.get() - greenlet = getcurrent() # pylint:disable=undefined-variable - idg = id(greenlet) - try: - entry = impl.dicts[idg] - dct = entry.localdict - except KeyError: - dct = _localimpl_create_dict(impl, greenlet, idg) - self.__init__(*impl.localargs, **impl.localkwargs) - return dct - -def _init(): - greenlet_init() # pylint:disable=undefined-variable - -_local_attrs = { - '_local__impl', - '_local_type_get_descriptors', - '_local_type_set_or_del_descriptors', - '_local_type_del_descriptors', - '_local_type_set_descriptors', - '_local_type', - '_local_type_vars', - '__class__', - '__cinit__', -} - -class local(object): - """ - An object whose attributes are greenlet-local. - """ - __slots__ = tuple(_local_attrs - {'__class__', '__cinit__'}) - - def __cinit__(self, *args, **kw): - if args or kw: - if type(self).__init__ == object.__init__: - raise TypeError("Initialization arguments are not supported", args, kw) - impl = _localimpl(args, kw, type(self), id(self)) - # pylint:disable=attribute-defined-outside-init - self._local__impl = impl - get, dels, sets_or_dels, sets = _local_find_descriptors(self) - self._local_type_get_descriptors = get - self._local_type_set_or_del_descriptors = sets_or_dels - self._local_type_del_descriptors = dels - self._local_type_set_descriptors = sets - self._local_type = type(self) - self._local_type_vars = set(dir(self._local_type)) - - def __getattribute__(self, name): # pylint:disable=too-many-return-statements - if name in _local_attrs: - # The _local__impl, __cinit__, etc, won't be hit by the - # Cython version, if we've done things right. If we haven't, - # they will be, and this will produce an error. - return object.__getattribute__(self, name) - - dct = _local_get_dict(self) - - if name == '__dict__': - return dct - # If there's no possible way we can switch, because this - # attribute is *not* found in the class where it might be a - # data descriptor (property), and it *is* in the dict - # then we don't need to swizzle the dict and take the lock. - - # We don't have to worry about people overriding __getattribute__ - # because if they did, the dict-swizzling would only last as - # long as we were in here anyway. - # Similarly, a __getattr__ will still be called by _oga() if needed - # if it's not in the dict. - - # Optimization: If we're not subclassed, then - # there can be no descriptors except for methods, which will - # never need to use __dict__. - if self._local_type is local: - return dct[name] if name in dct else object.__getattribute__(self, name) - - # NOTE: If this is a descriptor, this will invoke its __get__. - # A broken descriptor that doesn't return itself when called with - # a None for the instance argument could mess us up here. - # But this is faster than a loop over mro() checking each class __dict__ - # manually. - if name in dct: - if name not in self._local_type_vars: - # If there is a dict value, and nothing in the type, - # it can't possibly be a descriptor, so it is just returned. - return dct[name] - - # It's in the type *and* in the dict. If the type value is - # a data descriptor (defines __get__ *and* either __set__ or - # __delete__), then the type wins. If it's a non-data descriptor - # (defines just __get__), then the instance wins. If it's not a - # descriptor at all (doesn't have __get__), the instance wins. - # NOTE that the docs for descriptors say that these methods must be - # defined on the *class* of the object in the type. - if name not in self._local_type_get_descriptors: - # Entirely not a descriptor. Instance wins. - return dct[name] - if name in self._local_type_set_or_del_descriptors: - # A data descriptor. - # arbitrary code execution while these run. If they touch self again, - # they'll call back into us and we'll repeat the dance. - type_attr = getattr(self._local_type, name) - return type(type_attr).__get__(type_attr, self, self._local_type) - # Last case is a non-data descriptor. Instance wins. - return dct[name] - - if name in self._local_type_vars: - # Not in the dictionary, but is found in the type. It could be - # a non-data descriptor still. Some descriptors, like @staticmethod, - # return objects (functions, in this case), that are *themselves* - # descriptors, which when invoked, again, would do the wrong thing. - # So we can't rely on getattr() on the type for them, we have to - # look through the MRO dicts ourself. - if name not in self._local_type_get_descriptors: - # Not a descriptor, can't execute code. So all we need is - # the return value of getattr() on our type. - return getattr(self._local_type, name) - - for base in self._local_type.mro(): - bd = base.__dict__ - if name in bd: - attr_on_type = bd[name] - result = type(attr_on_type).__get__(attr_on_type, self, self._local_type) - return result - - # It wasn't in the dict and it wasn't in the type. - # So the next step is to invoke type(self)__getattr__, if it - # exists, otherwise raise an AttributeError. - # we will invoke type(self).__getattr__ or raise an attribute error. - if hasattr(self._local_type, '__getattr__'): - return self._local_type.__getattr__(self, name) - raise AttributeError("%r object has no attribute '%s'" - % (self._local_type.__name__, name)) - - def __setattr__(self, name, value): - if name == '__dict__': - raise AttributeError( - "%r object attribute '__dict__' is read-only" - % type(self)) - - if name in _local_attrs: - object.__setattr__(self, name, value) - return - - dct = _local_get_dict(self) - - if self._local_type is local: - # Optimization: If we're not subclassed, we can't - # have data descriptors, so this goes right in the dict. - dct[name] = value - return - - if name in self._local_type_vars: - if name in self._local_type_set_descriptors: - type_attr = getattr(self._local_type, name, _marker) - # A data descriptor, like a property or a slot. - type(type_attr).__set__(type_attr, self, value) - return - # Otherwise it goes directly in the dict - dct[name] = value - - def __delattr__(self, name): - if name == '__dict__': - raise AttributeError( - "%r object attribute '__dict__' is read-only" - % self.__class__.__name__) - - if name in self._local_type_vars: - if name in self._local_type_del_descriptors: - # A data descriptor, like a property or a slot. - type_attr = getattr(self._local_type, name, _marker) - type(type_attr).__delete__(type_attr, self) - return - # Otherwise it goes directly in the dict - - # Begin inlined function _get_dict() - dct = _local_get_dict(self) - - try: - del dct[name] - except KeyError: - raise AttributeError(name) - - def __copy__(self): - impl = self._local__impl - entry = impl.dicts[id(getcurrent())] # pylint:disable=undefined-variable - - dct = entry.localdict - duplicate = copy(dct) - - cls = type(self) - instance = cls(*impl.localargs, **impl.localkwargs) - _local__copy_dict_from(instance, impl, duplicate) - return instance - -def _local__copy_dict_from(self, impl, duplicate): - current = getcurrent() # pylint:disable=undefined-variable - currentId = id(current) - new_impl = self._local__impl - assert new_impl is not impl - entry = new_impl.dicts[currentId] - new_impl.dicts[currentId] = _localimpl_dict_entry(entry.wrgreenlet, duplicate) - -def _local_find_descriptors(self): - type_self = type(self) - gets = set() - dels = set() - set_or_del = set() - sets = set() - mro = list(type_self.mro()) - - for attr_name in dir(type_self): - # Conventionally, descriptors when called on a class - # return themself, but not all do. Notable exceptions are - # in the zope.interface package, where things like __provides__ - # return other class attributes. So we can't use getattr, and instead - # walk up the dicts - for base in mro: - bd = base.__dict__ - if attr_name in bd: - attr = bd[attr_name] - break - else: - raise AttributeError(attr_name) - - type_attr = type(attr) - if hasattr(type_attr, '__get__'): - gets.add(attr_name) - if hasattr(type_attr, '__delete__'): - dels.add(attr_name) - set_or_del.add(attr_name) - if hasattr(type_attr, '__set__'): - sets.add(attr_name) - - return (gets, dels, set_or_del, sets) - -# Cython doesn't let us use __new__, it requires -# __cinit__. But we need __new__ if we're not compiled -# (e.g., on PyPy). So we set it at runtime. Cython -# will raise an error if we're compiled. -def __new__(cls, *args, **kw): - self = super(local, cls).__new__(cls) - # We get the cls in *args for some reason - # too when we do it this way....except on PyPy3, which does - # not *unless* it's wrapped in a classmethod (which it is) - self.__cinit__(*args[1:], **kw) - return self - -try: - # PyPy2/3 and CPython handle adding a __new__ to the class - # in different ways. In CPython and PyPy3, it must be wrapped with classmethod; - # in PyPy2, it must not. In either case, the args that get passed to - # it are stil wrong. - local.__new__ = 'None' -except TypeError: # pragma: no cover - # Must be compiled - pass -else: - from gevent._compat import PYPY - from gevent._compat import PY2 - if PYPY and PY2: - local.__new__ = __new__ - else: - local.__new__ = classmethod(__new__) - - del PYPY - del PY2 - -_init() - -from gevent._util import import_c_accel -import_c_accel(globals(), 'gevent._local') |