automatic import of python-cachesopeneuler20.03

3 files changed, 686 insertions, 0 deletions

diff --git a/.gitignore b/.gitignore
index e69de29..2f793f1 100644
--- a/.gitignore
+++ b/.gitignore
@@ -0,0 +1 @@
+/caches-2.0.2.tar.gz
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
diff --git a/sources b/sources
new file mode 100644
index 0000000..60c5042
--- /dev/null
+++ b/sources
@@ -0,0 +1 @@
+90cdf84eba43ed76285586dd722f6494  caches-2.0.2.tar.gz