automatic import of python-limitlion

3 files changed, 233 insertions, 0 deletions

diff --git a/.gitignore b/.gitignore
index e69de29..17ac2f7 100644
--- a/.gitignore
+++ b/.gitignore
@@ -0,0 +1 @@
+/limitlion-1.0.0.tar.gz
diff --git a/python-limitlion.spec b/python-limitlion.spec
new file mode 100644
index 0000000..02b8b19
--- /dev/null
+++ b/python-limitlion.spec
@@ -0,0 +1,231 @@
+%global _empty_manifest_terminate_build 0
+Name:		python-limitlion
+Version:	1.0.0
+Release:	1
+Summary:	Close LimitLion
+License:	MIT License
+URL:		http://github.com/closeio/limitlion
+Source0:	https://mirrors.nju.edu.cn/pypi/web/packages/bc/f6/ded764d34564965d73cf0d33f17069fc236230706502646b2e744646708e/limitlion-1.0.0.tar.gz
+BuildArch:	noarch
+
+
+%description
+[![CircleCI](https://circleci.com/gh/closeio/limitlion.svg?style=svg)](https://circleci.com/gh/closeio/limitlion)
+# LimitLion
+
+A token bucket rate limiting throttle using Redis as the backend. Inspired by
+Stripe's [Scaling your API with rate limiters](https://stripe.com/blog/rate-limiters)
+blog post.  Can be used to control processing rates from one to many processes.
+Potential implementations include protecting databases from high processing rates,
+orchestrating queue consumer processes, or enforcing HTTP request rate limits.
+
+Install with: `pip install limitlion`
+
+Following is a simple example of a throttle named `test` that allows `5` requests per second (RPS) with
+a burst factor of `2` using a `8` second window and requesting `1` token (default)
+for each unit of work.  Look in the `examples` directory for more.
+
+```py
+redis = redis.Redis('localhost', 6379)
+throttle_configure(redis)
+while True:
+    allowed, tokens, sleep = throttle('test', 5, 2, 8)
+    if allowed:
+        print ('Do work here')
+    else:
+        print ('Sleeping {}'.format(sleep))
+        time.sleep(sleep)
+```
+
+## Design
+The rate limiting logic uses a classic token bucket algorithm but is implemented
+entirely as a Lua Redis script.  It leverages the Redis [TIME](https://redis.io/commands/time)
+command which ensures fair microsecond resolution across all callers independent
+of the caller's clock.  Note that buckets start and end on whole seconds.
+
+Redis 3.2+ is required because `replicate_commands()` is used to support using
+the `TIME` command in a Lua script.
+
+## Configuring
+Default values for RPS, burst factor and window size are supplied to the throttle
+Lua script.  The Lua script creates a `throttle:[throttle name]:knobs` hash with
+these values if it does not yet exist in Redis.  The script then uses the values
+in that `knobs` hash for the token bucket calculations.  Each call also sets the
+TTL for the `knobs` key to 7 days so it will remain in Redis as long as the
+throttle has been active in the last week.
+
+Since these settings are stored in Redis a separate process can be used to adjust
+them on the fly.  This could simply be manually issuing the Redis command to
+change the RPS or a more sophisicated process that polls Prometheus metrics to
+determine the current load on your database and adjust the RPS accordingly.
+
+# Running Counter
+Another small but useful tool to keep track of counts in Redis for specified
+time windows. These counts can then be used to make decisions on limiting or
+ failing processes as well as for diagnostics. Checkout [`running_counter.py
+`](limitlion/running_counter.py) for details.
+
+%package -n python3-limitlion
+Summary:	Close LimitLion
+Provides:	python-limitlion
+BuildRequires:	python3-devel
+BuildRequires:	python3-setuptools
+BuildRequires:	python3-pip
+%description -n python3-limitlion
+[![CircleCI](https://circleci.com/gh/closeio/limitlion.svg?style=svg)](https://circleci.com/gh/closeio/limitlion)
+# LimitLion
+
+A token bucket rate limiting throttle using Redis as the backend. Inspired by
+Stripe's [Scaling your API with rate limiters](https://stripe.com/blog/rate-limiters)
+blog post.  Can be used to control processing rates from one to many processes.
+Potential implementations include protecting databases from high processing rates,
+orchestrating queue consumer processes, or enforcing HTTP request rate limits.
+
+Install with: `pip install limitlion`
+
+Following is a simple example of a throttle named `test` that allows `5` requests per second (RPS) with
+a burst factor of `2` using a `8` second window and requesting `1` token (default)
+for each unit of work.  Look in the `examples` directory for more.
+
+```py
+redis = redis.Redis('localhost', 6379)
+throttle_configure(redis)
+while True:
+    allowed, tokens, sleep = throttle('test', 5, 2, 8)
+    if allowed:
+        print ('Do work here')
+    else:
+        print ('Sleeping {}'.format(sleep))
+        time.sleep(sleep)
+```
+
+## Design
+The rate limiting logic uses a classic token bucket algorithm but is implemented
+entirely as a Lua Redis script.  It leverages the Redis [TIME](https://redis.io/commands/time)
+command which ensures fair microsecond resolution across all callers independent
+of the caller's clock.  Note that buckets start and end on whole seconds.
+
+Redis 3.2+ is required because `replicate_commands()` is used to support using
+the `TIME` command in a Lua script.
+
+## Configuring
+Default values for RPS, burst factor and window size are supplied to the throttle
+Lua script.  The Lua script creates a `throttle:[throttle name]:knobs` hash with
+these values if it does not yet exist in Redis.  The script then uses the values
+in that `knobs` hash for the token bucket calculations.  Each call also sets the
+TTL for the `knobs` key to 7 days so it will remain in Redis as long as the
+throttle has been active in the last week.
+
+Since these settings are stored in Redis a separate process can be used to adjust
+them on the fly.  This could simply be manually issuing the Redis command to
+change the RPS or a more sophisicated process that polls Prometheus metrics to
+determine the current load on your database and adjust the RPS accordingly.
+
+# Running Counter
+Another small but useful tool to keep track of counts in Redis for specified
+time windows. These counts can then be used to make decisions on limiting or
+ failing processes as well as for diagnostics. Checkout [`running_counter.py
+`](limitlion/running_counter.py) for details.
+
+%package help
+Summary:	Development documents and examples for limitlion
+Provides:	python3-limitlion-doc
+%description help
+[![CircleCI](https://circleci.com/gh/closeio/limitlion.svg?style=svg)](https://circleci.com/gh/closeio/limitlion)
+# LimitLion
+
+A token bucket rate limiting throttle using Redis as the backend. Inspired by
+Stripe's [Scaling your API with rate limiters](https://stripe.com/blog/rate-limiters)
+blog post.  Can be used to control processing rates from one to many processes.
+Potential implementations include protecting databases from high processing rates,
+orchestrating queue consumer processes, or enforcing HTTP request rate limits.
+
+Install with: `pip install limitlion`
+
+Following is a simple example of a throttle named `test` that allows `5` requests per second (RPS) with
+a burst factor of `2` using a `8` second window and requesting `1` token (default)
+for each unit of work.  Look in the `examples` directory for more.
+
+```py
+redis = redis.Redis('localhost', 6379)
+throttle_configure(redis)
+while True:
+    allowed, tokens, sleep = throttle('test', 5, 2, 8)
+    if allowed:
+        print ('Do work here')
+    else:
+        print ('Sleeping {}'.format(sleep))
+        time.sleep(sleep)
+```
+
+## Design
+The rate limiting logic uses a classic token bucket algorithm but is implemented
+entirely as a Lua Redis script.  It leverages the Redis [TIME](https://redis.io/commands/time)
+command which ensures fair microsecond resolution across all callers independent
+of the caller's clock.  Note that buckets start and end on whole seconds.
+
+Redis 3.2+ is required because `replicate_commands()` is used to support using
+the `TIME` command in a Lua script.
+
+## Configuring
+Default values for RPS, burst factor and window size are supplied to the throttle
+Lua script.  The Lua script creates a `throttle:[throttle name]:knobs` hash with
+these values if it does not yet exist in Redis.  The script then uses the values
+in that `knobs` hash for the token bucket calculations.  Each call also sets the
+TTL for the `knobs` key to 7 days so it will remain in Redis as long as the
+throttle has been active in the last week.
+
+Since these settings are stored in Redis a separate process can be used to adjust
+them on the fly.  This could simply be manually issuing the Redis command to
+change the RPS or a more sophisicated process that polls Prometheus metrics to
+determine the current load on your database and adjust the RPS accordingly.
+
+# Running Counter
+Another small but useful tool to keep track of counts in Redis for specified
+time windows. These counts can then be used to make decisions on limiting or
+ failing processes as well as for diagnostics. Checkout [`running_counter.py
+`](limitlion/running_counter.py) for details.
+
+%prep
+%autosetup -n limitlion-1.0.0
+
+%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-limitlion -f filelist.lst
+%dir %{python3_sitelib}/*
+
+%files help -f doclist.lst
+%{_docdir}/*
+
+%changelog
+* Wed May 31 2023 Python_Bot <Python_Bot@openeuler.org> - 1.0.0-1
+- Package Spec generated
diff --git a/sources b/sources
new file mode 100644
index 0000000..0b81680
--- /dev/null
+++ b/sources
@@ -0,0 +1 @@
+441329e1bc382c97a627092958d19952  limitlion-1.0.0.tar.gz