py_tasks_melange: comparison app/django/utils/_threading

equal deleted inserted replaced

-:57b4279d8c4e
+:03e267d67478
+"""Thread-local objects
+(Note that this module provides a Python version of thread
+threading.local class.  Depending on the version of Python you're
+using, there may be a faster one available.  You should always import
+the local class from threading.)
+Thread-local objects support the management of thread-local data.
+If you have data that you want to be local to a thread, simply create
+a thread-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 thread-local objects is that their data are
+local to a thread. If we access the data in a different thread:
+>>> log = []
+>>> def f():
+...     items = mydata.__dict__.items()
+...     items.sort()
+...     log.append(items)
+...     mydata.number = 11
+...     log.append(mydata.number)
+>>> import threading
+>>> thread = threading.Thread(target=f)
+>>> thread.start()
+>>> thread.join()
+>>> log
+[[], 11]
+we get different data.  Furthermore, changes made in the other thread
+don't affect data seen in this thread:
+>>> mydata.number
+42
+Of course, values you get from a local object, including a __dict__
+attribute, are for whatever thread was current at the time the
+attribute was read.  For that reason, you generally don't want to save
+these values across threads, as they apply only to the thread 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 thread.  This
+is necessary to initialize each thread'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 thread:
+>>> log = []
+>>> thread = threading.Thread(target=f)
+>>> thread.start()
+>>> thread.join()
+>>> log
+[[('color', 'red'), ('initialized', True)], 11]
+without affecting this thread'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 thread
+local. They are shared across threads:
+>>> class MyLocal(local):
+...     __slots__ = 'number'
+>>> mydata = MyLocal()
+>>> mydata.number = 42
+>>> mydata.color = 'red'
+So, the separate thread:
+>>> thread = threading.Thread(target=f)
+>>> thread.start()
+>>> thread.join()
+affects what we see:
+>>> mydata.number
+11
+>>> del mydata
+"""
+# Threading import is at end
+class _localbase(object):
+__slots__ = '_local__key', '_local__args', '_local__lock'
+def __new__(cls, *args, **kw):
+self = object.__new__(cls)
+key = '_local__key', 'thread.local.' + str(id(self))
+object.__setattr__(self, '_local__key', key)
+object.__setattr__(self, '_local__args', (args, kw))
+object.__setattr__(self, '_local__lock', RLock())
+if args or kw and (cls.__init__ is object.__init__):
+raise TypeError("Initialization arguments are not supported")
+# We need to create the thread dict in anticipation of
+# __init__ being called, to make sure we don't call it
+# again ourselves.
+dict = object.__getattribute__(self, '__dict__')
+currentThread().__dict__[key] = dict
+return self
+def _patch(self):
+key = object.__getattribute__(self, '_local__key')
+d = currentThread().__dict__.get(key)
+if d is None:
+d = {}
+currentThread().__dict__[key] = d
+object.__setattr__(self, '__dict__', d)
+# we have a new instance dict, so call out __init__ if we have
+# one
+cls = type(self)
+if cls.__init__ is not object.__init__:
+args, kw = object.__getattribute__(self, '_local__args')
+cls.__init__(self, *args, **kw)
+else:
+object.__setattr__(self, '__dict__', d)
+class local(_localbase):
+def __getattribute__(self, name):
+lock = object.__getattribute__(self, '_local__lock')
+lock.acquire()
+try:
+_patch(self)
+return object.__getattribute__(self, name)
+finally:
+lock.release()
+def __setattr__(self, name, value):
+lock = object.__getattribute__(self, '_local__lock')
+lock.acquire()
+try:
+_patch(self)
+return object.__setattr__(self, name, value)
+finally:
+lock.release()
+def __delattr__(self, name):
+lock = object.__getattribute__(self, '_local__lock')
+lock.acquire()
+try:
+_patch(self)
+return object.__delattr__(self, name)
+finally:
+lock.release()
+def __del__():
+threading_enumerate = enumerate
+__getattribute__ = object.__getattribute__
+def __del__(self):
+key = __getattribute__(self, '_local__key')
+try:
+threads = list(threading_enumerate())
+except:
+# if enumerate fails, as it seems to do during
+# shutdown, we'll skip cleanup under the assumption
+# that there is nothing to clean up
+return
+for thread in threads:
+try:
+__dict__ = thread.__dict__
+except AttributeError:
+# Thread is dying, rest in peace
+continue
+if key in __dict__:
+try:
+del __dict__[key]
+except KeyError:
+pass # didn't have anything in this thread
+return __del__
+__del__ = __del__()
+try:
+from threading import currentThread, enumerate, RLock
+except ImportError:
+from dummy_threading import currentThread, enumerate, RLock