A decorator for caching properties in classes.
A decorator for caching properties in classes.
- Makes caching of time or computational expensive properties quick and easy.
- Because I got tired of copy/pasting this code from non-web project to non-web project.
- I needed something really simple that worked in Python 2 and 3.
How to use it
Let’s define a class with an expensive property. Every time you stay there the price goes up by $50!
class Monopoly(object): def __init__(self): self.boardwalk_price = 500 @property def boardwalk(self): # In reality, this might represent a database call or time # intensive task like calling a third-party API. self.boardwalk_price += 50 return self.boardwalk_price
Now run it:
>>> monopoly = Monopoly() >>> monopoly.boardwalk 550 >>> monopoly.boardwalk 600
Let’s convert the boardwalk property into a cached_property.
from cached_property import cached_property class Monopoly(object): def __init__(self): self.boardwalk_price = 500 @cached_property def boardwalk(self): # Again, this is a silly example. Don't worry about it, this is # just an example for clarity. self.boardwalk_price += 50 return self.boardwalk_price
Now when we run it the price stays at $550.
>>> monopoly = Monopoly() >>> monopoly.boardwalk 550 >>> monopoly.boardwalk 550 >>> monopoly.boardwalk 550
Why doesn’t the value of monopoly.boardwalk change? Because it’s a cached property!
Invalidating the Cache
Results of cached functions can be invalidated by outside forces. Let’s demonstrate how to force the cache to invalidate:
>>> monopoly = Monopoly() >>> monopoly.boardwalk 550 >>> monopoly.boardwalk 550 >>> # invalidate the cache >>> del monopoly.__dict__['boardwalk'] >>> # request the boardwalk property again >>> monopoly.boardwalk 600 >>> monopoly.boardwalk 600
Working with Threads
What if a whole bunch of people want to stay at Boardwalk all at once? This means using threads, which unfortunately causes problems with the standard cached_property. In this case, switch to using the threaded_cached_property:
from cached_property import threaded_cached_property class Monopoly(object): def __init__(self): self.boardwalk_price = 500 @threaded_cached_property def boardwalk(self): """threaded_cached_property is really nice for when no one waits for other people to finish their turn and rudely start rolling dice and moving their pieces.""" sleep(1) self.boardwalk_price += 50 return self.boardwalk_price
Now use it:
>>> from threading import Thread >>> from monopoly import Monopoly >>> monopoly = Monopoly() >>> threads =  >>> for x in range(10): >>> thread = Thread(target=lambda: monopoly.boardwalk) >>> thread.start() >>> threads.append(thread) >>> for thread in threads: >>> thread.join() >>> 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.
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:
>>> 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
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.
- Pip, Django, Werkzueg, Bottle, Pyramid, and Zope for having their own implementations. This package uses an implementation that matches the Bottle version.
- Reinout Van Rees for pointing out the cached_property decorator to me.
- My awesome wife @audreyr who created cookiecutter, which meant rolling this out took me just 15 minutes.
- @tinche for pointing out the threading issue and providing a solution.
- @bcho for providing the time-to-expire feature
Support This Project
This project is maintained by volunteers. Support their efforts by spreading the word about:
- Drop some non-ASCII characters from HISTORY.rst, thanks to @AdamWill
- Added official support for Python 3.5, thanks to @pydanny and @audreyr
- Removed confusingly placed lock from example, thanks to @ionelmc
- Corrected invalidation cache documentation, thanks to @proofit404
- Updated to latest Travis-CI environment, thanks to @audreyr
- Overall code and test refactoring, thanks to @gsakkis
- Allow the del statement for resetting cached properties with ttl instead of del obj._cache[attr], thanks to @gsakkis.
- Uncovered a bug in PyPy, https://bitbucket.org/pypy/pypy/issue/2033/attributeerror-object-attribute-is-read, thanks to @gsakkis
- Fixed threaded_cached_property_with_ttl to actually be thread-safe, thanks to @gsakkis
- Regression: As the cache was not always clearing, we’ve broken out the time to expire feature to its own set of specific tools, thanks to @pydanny
- Fixed typo in README, thanks to @zoidbergwill
- Added timed to expire feature to cached_property decorator.
- Backwards incompatiblity: Changed del monopoly.boardwalk to del monopoly['boardwalk'] in order to support the new TTL feature.
- Added threading support with new threaded_cached_property decorator
- Documented cache invalidation
- Updated credits
- Sourced the bottle implementation
- Fix the dang-blarged py_modules argument.
- Removed import of package into setup.py
- Documentation fixes. Not opening up a RTFD instance for this because it’s so simple to use.
- setup.py fix. Whoops!
- First release on PyPI.
Release history Release notifications
Download the file for your platform. If you're not sure which to choose, learn more about installing packages.
|Filename, size & hash SHA256 hash help||File type||Python version||Upload date|
|cached_property-1.3.0-py2.py3-none-any.whl (8.4 kB) Copy SHA256 hash SHA256||Wheel||2.7||Nov 25, 2015|
|cached-property-1.3.0.tar.gz (9.3 kB) Copy SHA256 hash SHA256||Source||None||Nov 25, 2015|