diff options
Diffstat (limited to 'python-caches.spec')
| -rw-r--r-- | python-caches.spec | 684 |
1 files changed, 684 insertions, 0 deletions
diff --git a/python-caches.spec b/python-caches.spec new file mode 100644 index 0000000..eba6f9a --- /dev/null +++ b/python-caches.spec @@ -0,0 +1,684 @@ +%global _empty_manifest_terminate_build 0 +Name: python-caches +Version: 2.0.2 +Release: 1 +Summary: Python caching backed by Redis +License: MIT +URL: http://github.com/jaymon/caches +Source0: https://mirrors.nju.edu.cn/pypi/web/packages/f9/92/eee22855612577d9de155af31896cb15bccf7b9447419157de8761dc7116/caches-2.0.2.tar.gz +BuildArch: noarch + + +%description +# Caches + +A Python caching library that gives a similar interface to standard Python data structures like Dict and Set but is backed by [Redis](https://redis.io). + +Caches has been used in production for years across many different products, handling millions of requests. + + +## How to use + +Caches can only use [Redis](http://redis.io). + +Caches relies on setting the environment variable `CACHES_DSN`: + + caches.interface.Redis://localhost/0 + +If you want to cache things using more than one redis server, you can actually set multiple environment variables: + + export CACHES_DSN_1=caches.interface.Redis://somedomain.com/0#redis1 + export CACHES_DSN_2=caches.interface.Redis://someotherdomain.com/0#redis2 + +After you've set the environment variable, then you just need to import caches in your code: + +```python +import caches +``` + +Caches will take care of parsing the url and creating the redis connection, automatically, so after the import Caches will be ready to use. + + +### Interface + +All caches caching classes have a similar interface, their constructor takes a key and data: + +```python +c = Cache(['foo', 'bar', 'che']) +print c.key # foo.bar.che +``` + +If you would like to init your cache object with a value, use the `data` `**kwarg`: + +```python +c = Cache('foo', data="boom!") +print c.key # foo +print c # "boom!" +``` + +Each caches base caching class is meant to be extended so you can set some parameters: + +* **serialize** -- boolean -- True if you want all values pickled, False if you don't (ie, you're caching ints or strings or something). + +* **prefix** -- string -- This will be prepended to the key args you pass into the constructor. + +* **ttl** -- integer -- time to live, how many seconds to cache the value. 0 (default) means cache forever. + +* **connection_name** -- string -- if you have more than one caches dsn then you can use this to set the name of the connection you want (the name of the connection is the `#connection_name` fragment of a dsn url). + +```python +class MyIntCache(Cache): + serialize = False # don't bother to serialize values since we're storing ints + prefix = "MyIntCache" # every key will have this prefix, change to invalidate all currently cached values + ttl = 7200 # store each int for 2 hours +``` + +### Cache Classes + + +#### Cache + +This is the traditional caching object, it sets a value into a key: + +```python +c = Cache('foo') +c.data = 5 # cache 5 +c += 10 # increment 5 by 10, store 15 in the cache + +c.clear() +print c # None +``` + + +#### DictCache + +This caching object acts more or less like a Python [dictionary](http://docs.python.org/3/library/stdtypes.html#mapping-types-dict): + +```python +c = DictCache('foo') +c['bar'] = 'b' +c['che'] = 'c' +for key, val in c.items(): + print key, val # will print "bar b" and then "che c" +``` + + +#### SetCache + +This caching object acts more or less like a Python [set](http://docs.python.org/2/library/stdtypes.html#set): + +```python +c = SetCache('foo') +c.add('bar') +c.add('che') +print 'che' in c # True +``` + + +#### SortedSetCache + +This caching object acts more or less like a Python [set](http://docs.python.org/2/library/stdtypes.html#set) but has some changes: + +* The `add()` method takes a tuple `(score, elem)` +* The `pop()` method will pop off the lowest score from the set, and pops a tuple `(score, elem)` +* An `rpop()` method allows you to pop the highest score from the set. +* Iterating through the set results in tuples of `(score, elem)`, not just elem like in a normal set or the `SetCache`. + +```python +c = SortedSetCache('foo') +c.add((1, 'bar')) +c.add((10, 'che')) +print 'che' in c # True +print c.pop() # (1, bar) +``` + + +#### SentinelCache + +Handy for gated access: + +```python +c = SentinelCache('foo') + +if not c: + print("sentinel value isn't set so do this") + +if not c: + print("sentinel value is now set so this will never run") +``` + + +### Decorator + +Caches exposes a decorator to make caching the return value of a function easy. This only works for `Cache` derived caching. + +The `cached` decorator can accept a caching class and also a key function (similar to the python [built-in `sorted()` function](http://docs.python.org/2/library/functions.html#sorted) key argument), except caches key argument returns a list that can be passed to the constructor of the caching class as `*args`. + +```python +import functools +from caches import Cache + +@Cache.cached(key="some_cache_key") +def foo(*args): + return functools.reduce(lambda x, y: x+y, args) + +foo(1, 2) # will compute the value and cache the return value +foo(1, 2) # return value from cache + +foo(1, 2, 3) # uh-oh, wrong value, our key was too static +``` + +Let's try again, this time with a dynamic key + +```python +@Cache.cached(key=lambda *args: args) +def foo(*args): + return functools.reduce(lambda x, y: x+y, args) + +foo(1, 2) # compute and cache, key func returned [1, 2] +foo(1, 2) # grabbed from cache +foo(1, 2, 3) # compute and cache because our key func returned [1, 2, 3] +``` + +What about custom caches classes? + +```python +class CustomCache(Cache): pass + +@CustomCache.cached(key=lambda *args: args) +def foo(*args): + return functools.reduce(lambda x, y: x+y, args) +``` + + +## Install + +Use pip from pypi: + + pip install caches + +or from source using pip: + + pip install -U "git+https://github.com/jaymon/caches#egg=caches" + + + +## License + +MIT + +## Other links + +* [redis_collections module](https://github.com/redis-collections/redis-collections) - If you need broader/deeper support for python standard types like dict and set then check out this project. Prior to 2.0.0 Caches had a dependency on this module. +* [Dogpile](http://dogpilecache.readthedocs.org/en/latest/usage.html) + + + + + +%package -n python3-caches +Summary: Python caching backed by Redis +Provides: python-caches +BuildRequires: python3-devel +BuildRequires: python3-setuptools +BuildRequires: python3-pip +%description -n python3-caches +# Caches + +A Python caching library that gives a similar interface to standard Python data structures like Dict and Set but is backed by [Redis](https://redis.io). + +Caches has been used in production for years across many different products, handling millions of requests. + + +## How to use + +Caches can only use [Redis](http://redis.io). + +Caches relies on setting the environment variable `CACHES_DSN`: + + caches.interface.Redis://localhost/0 + +If you want to cache things using more than one redis server, you can actually set multiple environment variables: + + export CACHES_DSN_1=caches.interface.Redis://somedomain.com/0#redis1 + export CACHES_DSN_2=caches.interface.Redis://someotherdomain.com/0#redis2 + +After you've set the environment variable, then you just need to import caches in your code: + +```python +import caches +``` + +Caches will take care of parsing the url and creating the redis connection, automatically, so after the import Caches will be ready to use. + + +### Interface + +All caches caching classes have a similar interface, their constructor takes a key and data: + +```python +c = Cache(['foo', 'bar', 'che']) +print c.key # foo.bar.che +``` + +If you would like to init your cache object with a value, use the `data` `**kwarg`: + +```python +c = Cache('foo', data="boom!") +print c.key # foo +print c # "boom!" +``` + +Each caches base caching class is meant to be extended so you can set some parameters: + +* **serialize** -- boolean -- True if you want all values pickled, False if you don't (ie, you're caching ints or strings or something). + +* **prefix** -- string -- This will be prepended to the key args you pass into the constructor. + +* **ttl** -- integer -- time to live, how many seconds to cache the value. 0 (default) means cache forever. + +* **connection_name** -- string -- if you have more than one caches dsn then you can use this to set the name of the connection you want (the name of the connection is the `#connection_name` fragment of a dsn url). + +```python +class MyIntCache(Cache): + serialize = False # don't bother to serialize values since we're storing ints + prefix = "MyIntCache" # every key will have this prefix, change to invalidate all currently cached values + ttl = 7200 # store each int for 2 hours +``` + +### Cache Classes + + +#### Cache + +This is the traditional caching object, it sets a value into a key: + +```python +c = Cache('foo') +c.data = 5 # cache 5 +c += 10 # increment 5 by 10, store 15 in the cache + +c.clear() +print c # None +``` + + +#### DictCache + +This caching object acts more or less like a Python [dictionary](http://docs.python.org/3/library/stdtypes.html#mapping-types-dict): + +```python +c = DictCache('foo') +c['bar'] = 'b' +c['che'] = 'c' +for key, val in c.items(): + print key, val # will print "bar b" and then "che c" +``` + + +#### SetCache + +This caching object acts more or less like a Python [set](http://docs.python.org/2/library/stdtypes.html#set): + +```python +c = SetCache('foo') +c.add('bar') +c.add('che') +print 'che' in c # True +``` + + +#### SortedSetCache + +This caching object acts more or less like a Python [set](http://docs.python.org/2/library/stdtypes.html#set) but has some changes: + +* The `add()` method takes a tuple `(score, elem)` +* The `pop()` method will pop off the lowest score from the set, and pops a tuple `(score, elem)` +* An `rpop()` method allows you to pop the highest score from the set. +* Iterating through the set results in tuples of `(score, elem)`, not just elem like in a normal set or the `SetCache`. + +```python +c = SortedSetCache('foo') +c.add((1, 'bar')) +c.add((10, 'che')) +print 'che' in c # True +print c.pop() # (1, bar) +``` + + +#### SentinelCache + +Handy for gated access: + +```python +c = SentinelCache('foo') + +if not c: + print("sentinel value isn't set so do this") + +if not c: + print("sentinel value is now set so this will never run") +``` + + +### Decorator + +Caches exposes a decorator to make caching the return value of a function easy. This only works for `Cache` derived caching. + +The `cached` decorator can accept a caching class and also a key function (similar to the python [built-in `sorted()` function](http://docs.python.org/2/library/functions.html#sorted) key argument), except caches key argument returns a list that can be passed to the constructor of the caching class as `*args`. + +```python +import functools +from caches import Cache + +@Cache.cached(key="some_cache_key") +def foo(*args): + return functools.reduce(lambda x, y: x+y, args) + +foo(1, 2) # will compute the value and cache the return value +foo(1, 2) # return value from cache + +foo(1, 2, 3) # uh-oh, wrong value, our key was too static +``` + +Let's try again, this time with a dynamic key + +```python +@Cache.cached(key=lambda *args: args) +def foo(*args): + return functools.reduce(lambda x, y: x+y, args) + +foo(1, 2) # compute and cache, key func returned [1, 2] +foo(1, 2) # grabbed from cache +foo(1, 2, 3) # compute and cache because our key func returned [1, 2, 3] +``` + +What about custom caches classes? + +```python +class CustomCache(Cache): pass + +@CustomCache.cached(key=lambda *args: args) +def foo(*args): + return functools.reduce(lambda x, y: x+y, args) +``` + + +## Install + +Use pip from pypi: + + pip install caches + +or from source using pip: + + pip install -U "git+https://github.com/jaymon/caches#egg=caches" + + + +## License + +MIT + +## Other links + +* [redis_collections module](https://github.com/redis-collections/redis-collections) - If you need broader/deeper support for python standard types like dict and set then check out this project. Prior to 2.0.0 Caches had a dependency on this module. +* [Dogpile](http://dogpilecache.readthedocs.org/en/latest/usage.html) + + + + + +%package help +Summary: Development documents and examples for caches +Provides: python3-caches-doc +%description help +# Caches + +A Python caching library that gives a similar interface to standard Python data structures like Dict and Set but is backed by [Redis](https://redis.io). + +Caches has been used in production for years across many different products, handling millions of requests. + + +## How to use + +Caches can only use [Redis](http://redis.io). + +Caches relies on setting the environment variable `CACHES_DSN`: + + caches.interface.Redis://localhost/0 + +If you want to cache things using more than one redis server, you can actually set multiple environment variables: + + export CACHES_DSN_1=caches.interface.Redis://somedomain.com/0#redis1 + export CACHES_DSN_2=caches.interface.Redis://someotherdomain.com/0#redis2 + +After you've set the environment variable, then you just need to import caches in your code: + +```python +import caches +``` + +Caches will take care of parsing the url and creating the redis connection, automatically, so after the import Caches will be ready to use. + + +### Interface + +All caches caching classes have a similar interface, their constructor takes a key and data: + +```python +c = Cache(['foo', 'bar', 'che']) +print c.key # foo.bar.che +``` + +If you would like to init your cache object with a value, use the `data` `**kwarg`: + +```python +c = Cache('foo', data="boom!") +print c.key # foo +print c # "boom!" +``` + +Each caches base caching class is meant to be extended so you can set some parameters: + +* **serialize** -- boolean -- True if you want all values pickled, False if you don't (ie, you're caching ints or strings or something). + +* **prefix** -- string -- This will be prepended to the key args you pass into the constructor. + +* **ttl** -- integer -- time to live, how many seconds to cache the value. 0 (default) means cache forever. + +* **connection_name** -- string -- if you have more than one caches dsn then you can use this to set the name of the connection you want (the name of the connection is the `#connection_name` fragment of a dsn url). + +```python +class MyIntCache(Cache): + serialize = False # don't bother to serialize values since we're storing ints + prefix = "MyIntCache" # every key will have this prefix, change to invalidate all currently cached values + ttl = 7200 # store each int for 2 hours +``` + +### Cache Classes + + +#### Cache + +This is the traditional caching object, it sets a value into a key: + +```python +c = Cache('foo') +c.data = 5 # cache 5 +c += 10 # increment 5 by 10, store 15 in the cache + +c.clear() +print c # None +``` + + +#### DictCache + +This caching object acts more or less like a Python [dictionary](http://docs.python.org/3/library/stdtypes.html#mapping-types-dict): + +```python +c = DictCache('foo') +c['bar'] = 'b' +c['che'] = 'c' +for key, val in c.items(): + print key, val # will print "bar b" and then "che c" +``` + + +#### SetCache + +This caching object acts more or less like a Python [set](http://docs.python.org/2/library/stdtypes.html#set): + +```python +c = SetCache('foo') +c.add('bar') +c.add('che') +print 'che' in c # True +``` + + +#### SortedSetCache + +This caching object acts more or less like a Python [set](http://docs.python.org/2/library/stdtypes.html#set) but has some changes: + +* The `add()` method takes a tuple `(score, elem)` +* The `pop()` method will pop off the lowest score from the set, and pops a tuple `(score, elem)` +* An `rpop()` method allows you to pop the highest score from the set. +* Iterating through the set results in tuples of `(score, elem)`, not just elem like in a normal set or the `SetCache`. + +```python +c = SortedSetCache('foo') +c.add((1, 'bar')) +c.add((10, 'che')) +print 'che' in c # True +print c.pop() # (1, bar) +``` + + +#### SentinelCache + +Handy for gated access: + +```python +c = SentinelCache('foo') + +if not c: + print("sentinel value isn't set so do this") + +if not c: + print("sentinel value is now set so this will never run") +``` + + +### Decorator + +Caches exposes a decorator to make caching the return value of a function easy. This only works for `Cache` derived caching. + +The `cached` decorator can accept a caching class and also a key function (similar to the python [built-in `sorted()` function](http://docs.python.org/2/library/functions.html#sorted) key argument), except caches key argument returns a list that can be passed to the constructor of the caching class as `*args`. + +```python +import functools +from caches import Cache + +@Cache.cached(key="some_cache_key") +def foo(*args): + return functools.reduce(lambda x, y: x+y, args) + +foo(1, 2) # will compute the value and cache the return value +foo(1, 2) # return value from cache + +foo(1, 2, 3) # uh-oh, wrong value, our key was too static +``` + +Let's try again, this time with a dynamic key + +```python +@Cache.cached(key=lambda *args: args) +def foo(*args): + return functools.reduce(lambda x, y: x+y, args) + +foo(1, 2) # compute and cache, key func returned [1, 2] +foo(1, 2) # grabbed from cache +foo(1, 2, 3) # compute and cache because our key func returned [1, 2, 3] +``` + +What about custom caches classes? + +```python +class CustomCache(Cache): pass + +@CustomCache.cached(key=lambda *args: args) +def foo(*args): + return functools.reduce(lambda x, y: x+y, args) +``` + + +## Install + +Use pip from pypi: + + pip install caches + +or from source using pip: + + pip install -U "git+https://github.com/jaymon/caches#egg=caches" + + + +## License + +MIT + +## Other links + +* [redis_collections module](https://github.com/redis-collections/redis-collections) - If you need broader/deeper support for python standard types like dict and set then check out this project. Prior to 2.0.0 Caches had a dependency on this module. +* [Dogpile](http://dogpilecache.readthedocs.org/en/latest/usage.html) + + + + + +%prep +%autosetup -n caches-2.0.2 + +%build +%py3_build + +%install +%py3_install +install -d -m755 %{buildroot}/%{_pkgdocdir} +if [ -d doc ]; then cp -arf doc %{buildroot}/%{_pkgdocdir}; fi +if [ -d docs ]; then cp -arf docs %{buildroot}/%{_pkgdocdir}; fi +if [ -d example ]; then cp -arf example %{buildroot}/%{_pkgdocdir}; fi +if [ -d examples ]; then cp -arf examples %{buildroot}/%{_pkgdocdir}; fi +pushd %{buildroot} +if [ -d usr/lib ]; then + find usr/lib -type f -printf "/%h/%f\n" >> filelist.lst +fi +if [ -d usr/lib64 ]; then + find usr/lib64 -type f -printf "/%h/%f\n" >> filelist.lst +fi +if [ -d usr/bin ]; then + find usr/bin -type f -printf "/%h/%f\n" >> filelist.lst +fi +if [ -d usr/sbin ]; then + find usr/sbin -type f -printf "/%h/%f\n" >> filelist.lst +fi +touch doclist.lst +if [ -d usr/share/man ]; then + find usr/share/man -type f -printf "/%h/%f.gz\n" >> doclist.lst +fi +popd +mv %{buildroot}/filelist.lst . +mv %{buildroot}/doclist.lst . + +%files -n python3-caches -f filelist.lst +%dir %{python3_sitelib}/* + +%files help -f doclist.lst +%{_docdir}/* + +%changelog +* Fri May 05 2023 Python_Bot <Python_Bot@openeuler.org> - 2.0.2-1 +- Package Spec generated |