mirror of https://github.com/django/django.git
Removed unused files from under django.utils.
git-svn-id: http://code.djangoproject.com/svn/django/trunk@16595 bcc190cf-cafb-0310-a4f2-bffc1f526a37
This commit is contained in:
parent
1d32bdd3c9
commit
42f256d512
|
@ -1,240 +0,0 @@
|
||||||
"""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
|
|
|
@ -1,42 +0,0 @@
|
||||||
# Performance note: I benchmarked this code using a set instead of
|
|
||||||
# a list for the stopwords and was surprised to find that the list
|
|
||||||
# performed /better/ than the set - maybe because it's only a small
|
|
||||||
# list.
|
|
||||||
|
|
||||||
stopwords = '''
|
|
||||||
i
|
|
||||||
a
|
|
||||||
an
|
|
||||||
are
|
|
||||||
as
|
|
||||||
at
|
|
||||||
be
|
|
||||||
by
|
|
||||||
for
|
|
||||||
from
|
|
||||||
how
|
|
||||||
in
|
|
||||||
is
|
|
||||||
it
|
|
||||||
of
|
|
||||||
on
|
|
||||||
or
|
|
||||||
that
|
|
||||||
the
|
|
||||||
this
|
|
||||||
to
|
|
||||||
was
|
|
||||||
what
|
|
||||||
when
|
|
||||||
where
|
|
||||||
'''.split()
|
|
||||||
|
|
||||||
def strip_stopwords(sentence):
|
|
||||||
"Removes stopwords - also normalizes whitespace"
|
|
||||||
words = sentence.split()
|
|
||||||
sentence = []
|
|
||||||
for word in words:
|
|
||||||
if word.lower() not in stopwords:
|
|
||||||
sentence.append(word)
|
|
||||||
return u' '.join(sentence)
|
|
||||||
|
|
Loading…
Reference in New Issue