Adding upstream version 1.1.0.
Signed-off-by: Mathias Behrle <mathiasb@m9s.biz>
This commit is contained in:
parent
edd243494a
commit
794062b3a1
10
HISTORY.rst
10
HISTORY.rst
|
@ -3,11 +3,17 @@
|
|||
History
|
||||
-------
|
||||
|
||||
1.0.0 (2014-02-13)
|
||||
1.1.0 (2015-04-04)
|
||||
++++++++++++++++++
|
||||
|
||||
* Regression: As the cache was not always clearing, we've broken out the time to expire feature to it's own set of specific tools.
|
||||
* Fixed typo in README, thanks to @zoidbergwill.
|
||||
|
||||
1.0.0 (2015-02-13)
|
||||
++++++++++++++++++
|
||||
|
||||
* Added timed to expire feature to ``cached_property`` decorator.
|
||||
* Changed ``del monopoly.boardwalk`` to ``del monopoly['boardwalk'] in order to support the new TTL feature.
|
||||
* **Backwards incompatiblity**: Changed ``del monopoly.boardwalk`` to ``del monopoly['boardwalk']`` in order to support the new TTL feature.
|
||||
|
||||
0.1.5 (2014-05-20)
|
||||
++++++++++++++++++
|
||||
|
|
89
PKG-INFO
89
PKG-INFO
|
@ -1,6 +1,6 @@
|
|||
Metadata-Version: 1.1
|
||||
Name: cached-property
|
||||
Version: 1.0.0
|
||||
Version: 1.1.0
|
||||
Summary: A cached-property for decorating methods in classes.
|
||||
Home-page: https://github.com/pydanny/cached-property
|
||||
Author: Daniel Greenfeld
|
||||
|
@ -12,7 +12,7 @@ Description: ===============================
|
|||
|
||||
.. image:: https://badge.fury.io/py/cached-property.png
|
||||
:target: http://badge.fury.io/py/cached-property
|
||||
|
||||
|
||||
.. image:: https://travis-ci.org/pydanny/cached-property.png?branch=master
|
||||
:target: https://travis-ci.org/pydanny/cached-property
|
||||
|
||||
|
@ -61,7 +61,6 @@ Description: ===============================
|
|||
|
||||
Let's convert the boardwalk property into a ``cached_property``.
|
||||
|
||||
|
||||
.. code-block:: python
|
||||
|
||||
from cached_property import cached_property
|
||||
|
@ -105,43 +104,12 @@ Description: ===============================
|
|||
>>> monopoly.boardwalk
|
||||
550
|
||||
>>> # invalidate the cache
|
||||
>>> del monopoly['boardwalk']
|
||||
>>> del monopoly.boardwalk
|
||||
>>> # request the boardwalk property again
|
||||
>>> monopoly.boardwalk
|
||||
600
|
||||
>>> monopoly.boardwalk
|
||||
600
|
||||
|
||||
Timing out the cache
|
||||
--------------------
|
||||
|
||||
Sometimes you want the price of things to reset after a time.
|
||||
|
||||
.. code-block:: python
|
||||
|
||||
import random
|
||||
from cached_property import cached_property
|
||||
|
||||
class Monopoly(object):
|
||||
|
||||
@cached_property(ttl=5) # cache invalidates after 10 seconds
|
||||
def dice(self):
|
||||
# I dare the reader to implement a game using this method of 'rolling dice'.
|
||||
return random.randint(2,12)
|
||||
|
||||
.. code-block:: python
|
||||
|
||||
>>> monopoly = Monopoly()
|
||||
>>> monopoly.dice
|
||||
10
|
||||
>>> monopoly.dice
|
||||
10
|
||||
>>> from time import sleep
|
||||
>>> sleep(6) # Sleeps long enough to expire the cache
|
||||
>>> monopoly.dice
|
||||
3
|
||||
>>> monopoly.dice
|
||||
3
|
||||
|
||||
Working with Threads
|
||||
---------------------
|
||||
|
@ -193,6 +161,47 @@ Description: ===============================
|
|||
>>> self.assertEqual(m.boardwalk, 550)
|
||||
|
||||
|
||||
Timing out the cache
|
||||
--------------------
|
||||
|
||||
Sometimes you want the price of things to reset after a time. Use the ``ttl``
|
||||
versions of ``cached_property`` and ``threaded_cached_property``.
|
||||
|
||||
.. code-block:: python
|
||||
|
||||
import random
|
||||
from cached_property import cached_property_with_ttl
|
||||
|
||||
class Monopoly(object):
|
||||
|
||||
@cached_property_with_ttl(ttl=5) # cache invalidates after 5 seconds
|
||||
def dice(self):
|
||||
# I dare the reader to implement a game using this method of 'rolling dice'.
|
||||
return random.randint(2,12)
|
||||
|
||||
Now use it:
|
||||
|
||||
.. code-block:: python
|
||||
|
||||
>>> monopoly = Monopoly()
|
||||
>>> monopoly.dice
|
||||
10
|
||||
>>> monopoly.dice
|
||||
10
|
||||
>>> from time import sleep
|
||||
>>> sleep(6) # Sleeps long enough to expire the cache
|
||||
>>> monopoly.dice
|
||||
3
|
||||
>>> monopoly.dice
|
||||
3
|
||||
>>> # This cache clearing does not always work, see note below.
|
||||
>>> del monopoly['dice']
|
||||
>>> monopoly.dice
|
||||
6
|
||||
|
||||
**Note:** The ``ttl`` tools do not reliably allow the clearing of the cache. This
|
||||
is why they are broken out into seperate tools. See https://github.com/pydanny/cached-property/issues/16.
|
||||
|
||||
Credits
|
||||
--------
|
||||
|
||||
|
@ -211,11 +220,17 @@ Description: ===============================
|
|||
History
|
||||
-------
|
||||
|
||||
1.0.0 (2014-02-13)
|
||||
1.1.0 (2015-04-04)
|
||||
++++++++++++++++++
|
||||
|
||||
* Regression: As the cache was not always clearing, we've broken out the time to expire feature to it's own set of specific tools.
|
||||
* Fixed typo in README, thanks to @zoidbergwill.
|
||||
|
||||
1.0.0 (2015-02-13)
|
||||
++++++++++++++++++
|
||||
|
||||
* Added timed to expire feature to ``cached_property`` decorator.
|
||||
* Changed ``del monopoly.boardwalk`` to ``del monopoly['boardwalk'] in order to support the new TTL feature.
|
||||
* **Backwards incompatiblity**: Changed ``del monopoly.boardwalk`` to ``del monopoly['boardwalk']`` in order to support the new TTL feature.
|
||||
|
||||
0.1.5 (2014-05-20)
|
||||
++++++++++++++++++
|
||||
|
|
77
README.rst
77
README.rst
|
@ -4,7 +4,7 @@ cached-property
|
|||
|
||||
.. image:: https://badge.fury.io/py/cached-property.png
|
||||
:target: http://badge.fury.io/py/cached-property
|
||||
|
||||
|
||||
.. image:: https://travis-ci.org/pydanny/cached-property.png?branch=master
|
||||
:target: https://travis-ci.org/pydanny/cached-property
|
||||
|
||||
|
@ -53,7 +53,6 @@ Now run it:
|
|||
|
||||
Let's convert the boardwalk property into a ``cached_property``.
|
||||
|
||||
|
||||
.. code-block:: python
|
||||
|
||||
from cached_property import cached_property
|
||||
|
@ -97,43 +96,12 @@ Results of cached functions can be invalidated by outside forces. Let's demonstr
|
|||
>>> monopoly.boardwalk
|
||||
550
|
||||
>>> # invalidate the cache
|
||||
>>> del monopoly['boardwalk']
|
||||
>>> del monopoly.boardwalk
|
||||
>>> # request the boardwalk property again
|
||||
>>> monopoly.boardwalk
|
||||
600
|
||||
>>> monopoly.boardwalk
|
||||
600
|
||||
|
||||
Timing out the cache
|
||||
--------------------
|
||||
|
||||
Sometimes you want the price of things to reset after a time.
|
||||
|
||||
.. code-block:: python
|
||||
|
||||
import random
|
||||
from cached_property import cached_property
|
||||
|
||||
class Monopoly(object):
|
||||
|
||||
@cached_property(ttl=5) # cache invalidates after 10 seconds
|
||||
def dice(self):
|
||||
# I dare the reader to implement a game using this method of 'rolling dice'.
|
||||
return random.randint(2,12)
|
||||
|
||||
.. code-block:: python
|
||||
|
||||
>>> monopoly = Monopoly()
|
||||
>>> monopoly.dice
|
||||
10
|
||||
>>> monopoly.dice
|
||||
10
|
||||
>>> from time import sleep
|
||||
>>> sleep(6) # Sleeps long enough to expire the cache
|
||||
>>> monopoly.dice
|
||||
3
|
||||
>>> monopoly.dice
|
||||
3
|
||||
|
||||
Working with Threads
|
||||
---------------------
|
||||
|
@ -185,6 +153,47 @@ Now use it:
|
|||
>>> self.assertEqual(m.boardwalk, 550)
|
||||
|
||||
|
||||
Timing out the cache
|
||||
--------------------
|
||||
|
||||
Sometimes you want the price of things to reset after a time. Use the ``ttl``
|
||||
versions of ``cached_property`` and ``threaded_cached_property``.
|
||||
|
||||
.. code-block:: python
|
||||
|
||||
import random
|
||||
from cached_property import cached_property_with_ttl
|
||||
|
||||
class Monopoly(object):
|
||||
|
||||
@cached_property_with_ttl(ttl=5) # cache invalidates after 5 seconds
|
||||
def dice(self):
|
||||
# I dare the reader to implement a game using this method of 'rolling dice'.
|
||||
return random.randint(2,12)
|
||||
|
||||
Now use it:
|
||||
|
||||
.. code-block:: python
|
||||
|
||||
>>> monopoly = Monopoly()
|
||||
>>> monopoly.dice
|
||||
10
|
||||
>>> monopoly.dice
|
||||
10
|
||||
>>> from time import sleep
|
||||
>>> sleep(6) # Sleeps long enough to expire the cache
|
||||
>>> monopoly.dice
|
||||
3
|
||||
>>> monopoly.dice
|
||||
3
|
||||
>>> # This cache clearing does not always work, see note below.
|
||||
>>> del monopoly['dice']
|
||||
>>> monopoly.dice
|
||||
6
|
||||
|
||||
**Note:** The ``ttl`` tools do not reliably allow the clearing of the cache. This
|
||||
is why they are broken out into seperate tools. See https://github.com/pydanny/cached-property/issues/16.
|
||||
|
||||
Credits
|
||||
--------
|
||||
|
||||
|
|
|
@ -1,6 +1,6 @@
|
|||
Metadata-Version: 1.1
|
||||
Name: cached-property
|
||||
Version: 1.0.0
|
||||
Version: 1.1.0
|
||||
Summary: A cached-property for decorating methods in classes.
|
||||
Home-page: https://github.com/pydanny/cached-property
|
||||
Author: Daniel Greenfeld
|
||||
|
@ -12,7 +12,7 @@ Description: ===============================
|
|||
|
||||
.. image:: https://badge.fury.io/py/cached-property.png
|
||||
:target: http://badge.fury.io/py/cached-property
|
||||
|
||||
|
||||
.. image:: https://travis-ci.org/pydanny/cached-property.png?branch=master
|
||||
:target: https://travis-ci.org/pydanny/cached-property
|
||||
|
||||
|
@ -61,7 +61,6 @@ Description: ===============================
|
|||
|
||||
Let's convert the boardwalk property into a ``cached_property``.
|
||||
|
||||
|
||||
.. code-block:: python
|
||||
|
||||
from cached_property import cached_property
|
||||
|
@ -105,43 +104,12 @@ Description: ===============================
|
|||
>>> monopoly.boardwalk
|
||||
550
|
||||
>>> # invalidate the cache
|
||||
>>> del monopoly['boardwalk']
|
||||
>>> del monopoly.boardwalk
|
||||
>>> # request the boardwalk property again
|
||||
>>> monopoly.boardwalk
|
||||
600
|
||||
>>> monopoly.boardwalk
|
||||
600
|
||||
|
||||
Timing out the cache
|
||||
--------------------
|
||||
|
||||
Sometimes you want the price of things to reset after a time.
|
||||
|
||||
.. code-block:: python
|
||||
|
||||
import random
|
||||
from cached_property import cached_property
|
||||
|
||||
class Monopoly(object):
|
||||
|
||||
@cached_property(ttl=5) # cache invalidates after 10 seconds
|
||||
def dice(self):
|
||||
# I dare the reader to implement a game using this method of 'rolling dice'.
|
||||
return random.randint(2,12)
|
||||
|
||||
.. code-block:: python
|
||||
|
||||
>>> monopoly = Monopoly()
|
||||
>>> monopoly.dice
|
||||
10
|
||||
>>> monopoly.dice
|
||||
10
|
||||
>>> from time import sleep
|
||||
>>> sleep(6) # Sleeps long enough to expire the cache
|
||||
>>> monopoly.dice
|
||||
3
|
||||
>>> monopoly.dice
|
||||
3
|
||||
|
||||
Working with Threads
|
||||
---------------------
|
||||
|
@ -193,6 +161,47 @@ Description: ===============================
|
|||
>>> self.assertEqual(m.boardwalk, 550)
|
||||
|
||||
|
||||
Timing out the cache
|
||||
--------------------
|
||||
|
||||
Sometimes you want the price of things to reset after a time. Use the ``ttl``
|
||||
versions of ``cached_property`` and ``threaded_cached_property``.
|
||||
|
||||
.. code-block:: python
|
||||
|
||||
import random
|
||||
from cached_property import cached_property_with_ttl
|
||||
|
||||
class Monopoly(object):
|
||||
|
||||
@cached_property_with_ttl(ttl=5) # cache invalidates after 5 seconds
|
||||
def dice(self):
|
||||
# I dare the reader to implement a game using this method of 'rolling dice'.
|
||||
return random.randint(2,12)
|
||||
|
||||
Now use it:
|
||||
|
||||
.. code-block:: python
|
||||
|
||||
>>> monopoly = Monopoly()
|
||||
>>> monopoly.dice
|
||||
10
|
||||
>>> monopoly.dice
|
||||
10
|
||||
>>> from time import sleep
|
||||
>>> sleep(6) # Sleeps long enough to expire the cache
|
||||
>>> monopoly.dice
|
||||
3
|
||||
>>> monopoly.dice
|
||||
3
|
||||
>>> # This cache clearing does not always work, see note below.
|
||||
>>> del monopoly['dice']
|
||||
>>> monopoly.dice
|
||||
6
|
||||
|
||||
**Note:** The ``ttl`` tools do not reliably allow the clearing of the cache. This
|
||||
is why they are broken out into seperate tools. See https://github.com/pydanny/cached-property/issues/16.
|
||||
|
||||
Credits
|
||||
--------
|
||||
|
||||
|
@ -211,11 +220,17 @@ Description: ===============================
|
|||
History
|
||||
-------
|
||||
|
||||
1.0.0 (2014-02-13)
|
||||
1.1.0 (2015-04-04)
|
||||
++++++++++++++++++
|
||||
|
||||
* Regression: As the cache was not always clearing, we've broken out the time to expire feature to it's own set of specific tools.
|
||||
* Fixed typo in README, thanks to @zoidbergwill.
|
||||
|
||||
1.0.0 (2015-02-13)
|
||||
++++++++++++++++++
|
||||
|
||||
* Added timed to expire feature to ``cached_property`` decorator.
|
||||
* Changed ``del monopoly.boardwalk`` to ``del monopoly['boardwalk'] in order to support the new TTL feature.
|
||||
* **Backwards incompatiblity**: Changed ``del monopoly.boardwalk`` to ``del monopoly['boardwalk']`` in order to support the new TTL feature.
|
||||
|
||||
0.1.5 (2014-05-20)
|
||||
++++++++++++++++++
|
||||
|
|
|
@ -14,4 +14,5 @@ cached_property.egg-info/not-zip-safe
|
|||
cached_property.egg-info/top_level.txt
|
||||
tests/__init__.py
|
||||
tests/test_cached_property.py
|
||||
tests/test_cached_property_ttl.py
|
||||
tests/test_threaded_cached_property.py
|
|
@ -2,7 +2,7 @@
|
|||
|
||||
__author__ = 'Daniel Greenfeld'
|
||||
__email__ = 'pydanny@gmail.com'
|
||||
__version__ = '1.0.0'
|
||||
__version__ = '1.1.0'
|
||||
__license__ = 'BSD'
|
||||
|
||||
from time import time
|
||||
|
@ -13,8 +13,44 @@ class cached_property(object):
|
|||
""" A property that is only computed once per instance and then replaces
|
||||
itself with an ordinary attribute. Deleting the attribute resets the
|
||||
property.
|
||||
|
||||
Source: https://github.com/bottlepy/bottle/commit/fa7733e075da0d790d809aa3d2f53071897e6f76
|
||||
"""
|
||||
|
||||
def __init__(self, func):
|
||||
self.__doc__ = getattr(func, '__doc__')
|
||||
self.func = func
|
||||
|
||||
def __get__(self, obj, cls):
|
||||
if obj is None:
|
||||
return self
|
||||
value = obj.__dict__[self.func.__name__] = self.func(obj)
|
||||
return value
|
||||
|
||||
|
||||
class threaded_cached_property(cached_property):
|
||||
""" A cached_property version for use in environments where multiple
|
||||
threads might concurrently try to access the property.
|
||||
"""
|
||||
def __init__(self, func):
|
||||
super(threaded_cached_property, self).__init__(func)
|
||||
self.lock = threading.RLock()
|
||||
|
||||
def __get__(self, obj, cls):
|
||||
with self.lock:
|
||||
# Double check if the value was computed before the lock was
|
||||
# acquired.
|
||||
prop_name = self.func.__name__
|
||||
if prop_name in obj.__dict__:
|
||||
return obj.__dict__[prop_name]
|
||||
|
||||
# If not, do the calculation and release the lock.
|
||||
return super(threaded_cached_property, self).__get__(obj, cls)
|
||||
|
||||
|
||||
class cached_property_with_ttl(object):
|
||||
""" A property that is only computed once per instance and then replaces
|
||||
itself with an ordinary attribute. Setting the ttl to a number expresses
|
||||
how long the property will last before being timed out.
|
||||
""" # noqa
|
||||
|
||||
def __init__(self, ttl=None):
|
||||
|
@ -55,16 +91,17 @@ class cached_property(object):
|
|||
|
||||
return value
|
||||
|
||||
def __delattr__(self, name):
|
||||
print(name)
|
||||
# Aliases to make cached_property_with_ttl easier to use
|
||||
cached_property_ttl = cached_property_with_ttl
|
||||
timed_cached_property = cached_property_with_ttl
|
||||
|
||||
|
||||
class threaded_cached_property(cached_property):
|
||||
class threaded_cached_property_with_ttl(cached_property_with_ttl):
|
||||
""" A cached_property version for use in environments where multiple
|
||||
threads might concurrently try to access the property.
|
||||
"""
|
||||
def __init__(self, ttl=None):
|
||||
super(threaded_cached_property, self).__init__(ttl)
|
||||
super(threaded_cached_property_with_ttl, self).__init__(ttl)
|
||||
self.lock = threading.RLock()
|
||||
|
||||
def __get__(self, obj, cls):
|
||||
|
@ -76,4 +113,9 @@ class threaded_cached_property(cached_property):
|
|||
return obj._cache[prop_name][0]
|
||||
|
||||
# If not, do the calculation and release the lock.
|
||||
return super(threaded_cached_property, self).__get__(obj, cls)
|
||||
return super(threaded_cached_property_with_ttl, self).__get__(obj, cls)
|
||||
|
||||
# Alias to make threaded_cached_property_with_ttl easier to use
|
||||
threaded_cached_property_ttl = threaded_cached_property_with_ttl
|
||||
timed_threaded_cached_property = threaded_cached_property_with_ttl
|
||||
|
||||
|
|
2
setup.py
2
setup.py
|
@ -9,7 +9,7 @@ try:
|
|||
except ImportError:
|
||||
from distutils.core import setup
|
||||
|
||||
__version__ = '1.0.0'
|
||||
__version__ = '1.1.0'
|
||||
|
||||
readme = open('README.rst').read()
|
||||
history = open('HISTORY.rst').read().replace('.. :changelog:', '')
|
||||
|
|
|
@ -10,7 +10,6 @@ Tests for `cached-property` module.
|
|||
from time import sleep
|
||||
from threading import Lock, Thread
|
||||
import unittest
|
||||
from freezegun import freeze_time
|
||||
|
||||
from cached_property import cached_property
|
||||
|
||||
|
@ -45,10 +44,6 @@ class TestCachedProperty(unittest.TestCase):
|
|||
self.assertEqual(c.add_cached, 1)
|
||||
self.assertEqual(c.add_cached, 1)
|
||||
|
||||
# Cannot expire the cache.
|
||||
with freeze_time("9999-01-01"):
|
||||
self.assertEqual(c.add_cached, 1)
|
||||
|
||||
# It's customary for descriptors to return themselves if accessed
|
||||
# though the class, rather than through an instance.
|
||||
self.assertTrue(isinstance(Check.add_cached, cached_property))
|
||||
|
@ -72,7 +67,7 @@ class TestCachedProperty(unittest.TestCase):
|
|||
self.assertEqual(c.add_cached, 1)
|
||||
|
||||
# Reset the cache.
|
||||
del c._cache['add_cached']
|
||||
del c.add_cached
|
||||
self.assertEqual(c.add_cached, 2)
|
||||
self.assertEqual(c.add_cached, 2)
|
||||
|
||||
|
@ -98,7 +93,7 @@ class TestThreadingIssues(unittest.TestCase):
|
|||
def test_threads(self):
|
||||
""" How well does the standard cached_property implementation work with threads?
|
||||
Short answer: It doesn't! Use threaded_cached_property instead!
|
||||
""" # noqa
|
||||
"""
|
||||
|
||||
class Check(object):
|
||||
|
||||
|
@ -135,29 +130,3 @@ class TestThreadingIssues(unittest.TestCase):
|
|||
# between 1 and num_threads, depending on thread scheduling and
|
||||
# preemption.
|
||||
self.assertEqual(c.add_cached, num_threads)
|
||||
|
||||
|
||||
class TestCachedPropertyWithTTL(unittest.TestCase):
|
||||
|
||||
def test_ttl_expiry(self):
|
||||
|
||||
class Check(object):
|
||||
|
||||
def __init__(self):
|
||||
self.total = 0
|
||||
|
||||
@cached_property(ttl=100000)
|
||||
def add_cached(self):
|
||||
self.total += 1
|
||||
return self.total
|
||||
|
||||
c = Check()
|
||||
|
||||
# Run standard cache assertion
|
||||
self.assertEqual(c.add_cached, 1)
|
||||
self.assertEqual(c.add_cached, 1)
|
||||
|
||||
# Expire the cache.
|
||||
with freeze_time("9999-01-01"):
|
||||
self.assertEqual(c.add_cached, 2)
|
||||
self.assertEqual(c.add_cached, 2)
|
||||
|
|
|
@ -0,0 +1,274 @@
|
|||
# -*- coding: utf-8 -*-
|
||||
|
||||
"""
|
||||
test_threaded_cache_property.py
|
||||
----------------------------------
|
||||
|
||||
Tests for `cached-property` module, cached_property_with_ttl.
|
||||
Tests for `cached-property` module, threaded_cache_property_with_ttl.
|
||||
"""
|
||||
import unittest
|
||||
from freezegun import freeze_time
|
||||
|
||||
from cached_property import (
|
||||
cached_property_with_ttl,
|
||||
threaded_cached_property_with_ttl
|
||||
)
|
||||
|
||||
|
||||
from time import sleep
|
||||
from threading import Lock, Thread
|
||||
import unittest
|
||||
from freezegun import freeze_time
|
||||
|
||||
from cached_property import cached_property
|
||||
|
||||
|
||||
class TestCachedProperty(unittest.TestCase):
|
||||
|
||||
def test_cached_property(self):
|
||||
|
||||
class Check(object):
|
||||
|
||||
def __init__(self):
|
||||
self.total1 = 0
|
||||
self.total2 = 0
|
||||
|
||||
@property
|
||||
def add_control(self):
|
||||
self.total1 += 1
|
||||
return self.total1
|
||||
|
||||
@cached_property_with_ttl
|
||||
def add_cached(self):
|
||||
self.total2 += 1
|
||||
return self.total2
|
||||
|
||||
c = Check()
|
||||
|
||||
# The control shows that we can continue to add 1.
|
||||
self.assertEqual(c.add_control, 1)
|
||||
self.assertEqual(c.add_control, 2)
|
||||
|
||||
# The cached version demonstrates how nothing new is added
|
||||
self.assertEqual(c.add_cached, 1)
|
||||
self.assertEqual(c.add_cached, 1)
|
||||
|
||||
# Cannot expire the cache.
|
||||
with freeze_time("9999-01-01"):
|
||||
self.assertEqual(c.add_cached, 1)
|
||||
|
||||
# It's customary for descriptors to return themselves if accessed
|
||||
# though the class, rather than through an instance.
|
||||
self.assertTrue(isinstance(Check.add_cached, cached_property_with_ttl))
|
||||
|
||||
def test_reset_cached_property(self):
|
||||
|
||||
class Check(object):
|
||||
|
||||
def __init__(self):
|
||||
self.total = 0
|
||||
|
||||
@cached_property_with_ttl
|
||||
def add_cached(self):
|
||||
self.total += 1
|
||||
return self.total
|
||||
|
||||
c = Check()
|
||||
|
||||
# Run standard cache assertion
|
||||
self.assertEqual(c.add_cached, 1)
|
||||
self.assertEqual(c.add_cached, 1)
|
||||
|
||||
# Reset the cache.
|
||||
del c._cache['add_cached']
|
||||
self.assertEqual(c.add_cached, 2)
|
||||
self.assertEqual(c.add_cached, 2)
|
||||
|
||||
def test_none_cached_property(self):
|
||||
|
||||
class Check(object):
|
||||
|
||||
def __init__(self):
|
||||
self.total = None
|
||||
|
||||
@cached_property_with_ttl
|
||||
def add_cached(self):
|
||||
return self.total
|
||||
|
||||
c = Check()
|
||||
|
||||
# Run standard cache assertion
|
||||
self.assertEqual(c.add_cached, None)
|
||||
|
||||
|
||||
class TestThreadingIssues(unittest.TestCase):
|
||||
|
||||
def test_threads(self):
|
||||
""" How well does the standard cached_property implementation work with threads?
|
||||
Short answer: It doesn't! Use threaded_cached_property instead!
|
||||
""" # noqa
|
||||
|
||||
class Check(object):
|
||||
|
||||
def __init__(self):
|
||||
self.total = 0
|
||||
self.lock = Lock()
|
||||
|
||||
@cached_property_with_ttl
|
||||
def add_cached(self):
|
||||
sleep(1)
|
||||
# Need to guard this since += isn't atomic.
|
||||
with self.lock:
|
||||
self.total += 1
|
||||
return self.total
|
||||
|
||||
c = Check()
|
||||
threads = []
|
||||
num_threads = 10
|
||||
for x in range(num_threads):
|
||||
thread = Thread(target=lambda: c.add_cached)
|
||||
thread.start()
|
||||
threads.append(thread)
|
||||
|
||||
for thread in threads:
|
||||
thread.join()
|
||||
|
||||
# Threads means that caching is bypassed.
|
||||
self.assertNotEqual(c.add_cached, 1)
|
||||
|
||||
# This assertion hinges on the fact the system executing the test can
|
||||
# spawn and start running num_threads threads within the sleep period
|
||||
# (defined in the Check class as 1 second). If num_threads were to be
|
||||
# massively increased (try 10000), the actual value returned would be
|
||||
# between 1 and num_threads, depending on thread scheduling and
|
||||
# preemption.
|
||||
self.assertEqual(c.add_cached, num_threads)
|
||||
|
||||
|
||||
class TestCachedPropertyWithTTL(unittest.TestCase):
|
||||
|
||||
def test_ttl_expiry(self):
|
||||
|
||||
class Check(object):
|
||||
|
||||
def __init__(self):
|
||||
self.total = 0
|
||||
|
||||
@cached_property_with_ttl(ttl=100000)
|
||||
def add_cached(self):
|
||||
self.total += 1
|
||||
return self.total
|
||||
|
||||
c = Check()
|
||||
|
||||
# Run standard cache assertion
|
||||
self.assertEqual(c.add_cached, 1)
|
||||
self.assertEqual(c.add_cached, 1)
|
||||
|
||||
# Expire the cache.
|
||||
with freeze_time("9999-01-01"):
|
||||
self.assertEqual(c.add_cached, 2)
|
||||
self.assertEqual(c.add_cached, 2)
|
||||
|
||||
|
||||
class TestCachedProperty(unittest.TestCase):
|
||||
|
||||
def test_cached_property(self):
|
||||
|
||||
class Check(object):
|
||||
|
||||
def __init__(self):
|
||||
self.total1 = 0
|
||||
self.total2 = 0
|
||||
|
||||
@property
|
||||
def add_control(self):
|
||||
self.total1 += 1
|
||||
return self.total1
|
||||
|
||||
@threaded_cached_property_with_ttl
|
||||
def add_cached(self):
|
||||
self.total2 += 1
|
||||
return self.total2
|
||||
|
||||
c = Check()
|
||||
|
||||
# The control shows that we can continue to add 1.
|
||||
self.assertEqual(c.add_control, 1)
|
||||
self.assertEqual(c.add_control, 2)
|
||||
|
||||
# The cached version demonstrates how nothing new is added
|
||||
self.assertEqual(c.add_cached, 1)
|
||||
self.assertEqual(c.add_cached, 1)
|
||||
|
||||
def test_reset_cached_property(self):
|
||||
|
||||
class Check(object):
|
||||
|
||||
def __init__(self):
|
||||
self.total = 0
|
||||
|
||||
@threaded_cached_property_with_ttl
|
||||
def add_cached(self):
|
||||
self.total += 1
|
||||
return self.total
|
||||
|
||||
c = Check()
|
||||
|
||||
# Run standard cache assertion
|
||||
self.assertEqual(c.add_cached, 1)
|
||||
self.assertEqual(c.add_cached, 1)
|
||||
|
||||
# Reset the cache.
|
||||
del c._cache['add_cached']
|
||||
self.assertEqual(c.add_cached, 2)
|
||||
self.assertEqual(c.add_cached, 2)
|
||||
|
||||
def test_none_cached_property(self):
|
||||
|
||||
class Check(object):
|
||||
|
||||
def __init__(self):
|
||||
self.total = None
|
||||
|
||||
@threaded_cached_property_with_ttl
|
||||
def add_cached(self):
|
||||
return self.total
|
||||
|
||||
c = Check()
|
||||
|
||||
# Run standard cache assertion
|
||||
self.assertEqual(c.add_cached, None)
|
||||
|
||||
|
||||
class TestThreadingIssues(unittest.TestCase):
|
||||
|
||||
def test_threads(self):
|
||||
""" How well does this implementation work with threads?"""
|
||||
|
||||
class Check(object):
|
||||
|
||||
def __init__(self):
|
||||
self.total = 0
|
||||
self.lock = Lock()
|
||||
|
||||
@threaded_cached_property_with_ttl
|
||||
def add_cached(self):
|
||||
sleep(1)
|
||||
# Need to guard this since += isn't atomic.
|
||||
with self.lock:
|
||||
self.total += 1
|
||||
return self.total
|
||||
|
||||
c = Check()
|
||||
threads = []
|
||||
for x in range(10):
|
||||
thread = Thread(target=lambda: c.add_cached)
|
||||
thread.start()
|
||||
threads.append(thread)
|
||||
|
||||
for thread in threads:
|
||||
thread.join()
|
||||
|
||||
self.assertEqual(c.add_cached, 1)
|
|
@ -3,7 +3,6 @@
|
|||
"""
|
||||
test_threaded_cache_property.py
|
||||
----------------------------------
|
||||
|
||||
Tests for `cached-property` module, threaded_cache_property.
|
||||
"""
|
||||
|
||||
|
@ -63,7 +62,7 @@ class TestCachedProperty(unittest.TestCase):
|
|||
self.assertEqual(c.add_cached, 1)
|
||||
|
||||
# Reset the cache.
|
||||
del c._cache['add_cached']
|
||||
del c.add_cached
|
||||
self.assertEqual(c.add_cached, 2)
|
||||
self.assertEqual(c.add_cached, 2)
|
||||
|
||||
|
|
Loading…
Reference in New Issue