httpx-limiter 0.3.0__tar.gz → 0.5.0__tar.gz

httpx_limiter-0.5.0/PKG-INFO

@@ -0,0 +1,217 @@
+Metadata-Version: 2.4
+Name: httpx-limiter
+Version: 0.5.0
+Summary: A lightweight package that provides rate-limited httpx transports.
+Project-URL: Homepage, https://github.com/Midnighter/httpx-limiter
+Project-URL: Documentation, https://httpx-limiter.readthedocs.io
+Project-URL: Source Code, https://github.com/Midnighter/httpx-limiter
+Project-URL: Bug Tracker, https://github.com/Midnighter/httpx-limiter/issues
+Project-URL: Download, https://pypi.org/project/httpx-limiter/#files
+Author-email: "Moritz E. Beber" <midnighter@posteo.net>
+License-Expression: Apache-2.0
+License-File: LICENSE
+Keywords: httpx,leaky bucket,limiter,rate-limit
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Environment :: Web Environment
+Classifier: Framework :: AsyncIO
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Natural Language :: English
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Requires-Dist: httpx~=0.25
+Requires-Dist: typing-extensions~=4.6; python_version < '3.11'
+Provides-Extra: aiolimiter
+Requires-Dist: aiolimiter~=1.2; extra == 'aiolimiter'
+Provides-Extra: pyrate
+Requires-Dist: pyrate-limiter~=3.9; extra == 'pyrate'
+Description-Content-Type: text/markdown
+
+# HTTPX Limiter
+
+|            |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
+| ---------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Package    | [![Latest PyPI Version](https://img.shields.io/pypi/v/httpx-limiter.svg)](https://pypi.org/project/httpx-limiter/) [![Supported Python Versions](https://img.shields.io/pypi/pyversions/httpx-limiter.svg)](https://pypi.org/project/httpx-limiter/)                                                                                                                                                                                                                                                                                                                                                 |
+| Meta       | [![Apache-2.0](https://img.shields.io/pypi/l/httpx-limiter.svg)](LICENSE) [![Code of Conduct](https://img.shields.io/badge/Contributor%20Covenant-v2.0%20adopted-ff69b4.svg)](.github/CODE_OF_CONDUCT.md) [![Checked with mypy](https://www.mypy-lang.org/static/mypy_badge.svg)](https://mypy-lang.org/) [![Code Style Black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/ambv/black) [![Linting: Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/charliermarsh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff) |
+| Automation | [![CI](https://github.com/Midnighter/httpx-limiter/actions/workflows/main.yml/badge.svg)](https://github.com/Midnighter/httpx-limiter/actions/workflows/main.yml)                                                                                                                                                                                                                                                                                                                                                                                                                                    |
+
+_A lightweight package that provides rate-limited httpx transports._
+
+## Installation
+
+The package is published on [PyPI](https://pypi.org/project/httpx-limiter/). Install it,
+for example, with the aiolimiter backend.
+
+```sh
+pip install 'httpx-limiter[aiolimiter]'
+```
+
+There is also a pyrate-limiter backend available.
+
+```sh
+pip install 'httpx-limiter[pyrate]'
+```
+
+## Rate Limiter Backends
+
+This package provides two different asynchronous rate limiter implementations to choose
+from:
+
+1. [aiolimiter](https://aiolimiter.readthedocs.io)
+2. [pyrate-limiter](https://pyratelimiter.readthedocs.io)
+
+> [!IMPORTANT]
+> While both implementations fulfill similar purposes, there are significant differences
+> between them. Please read the descriptions below to make an informed decision about
+> which one best suits your needs.
+
+### 1. aiolimiter
+
+-   **Single rate limit only**: Supports only one rate limit at a time
+-   **Lightweight**: Minimal dependencies and simpler configuration
+-   **Linear token refresh rate**: As an example, if you set a rate of 2 per second,
+    roughly one token will be added every 500 milliseconds
+
+```python
+from httpx_limiter.aiolimiter import AiolimiterAsyncLimiter
+
+limiter = AiolimiterAsyncLimiter.create(Rate.create(magnitude=20))
+```
+
+### 2. pyrate-limiter
+
+-   **Multiple rate limits**: Support for multiple concurrent rate limits, for example,
+    10 requests per second _and_ 100 requests per minute
+-   **Flexible configuration**: Comprehensive configuration options
+-   **Multiprocessing dependency**: Current implementation depends on `multiprocessing`
+    which may not be available in all environments, such as pyodide
+-   **Stepwise token refresh rate**: As an example, if you set a rate of 2 per second,
+    two token will be added every second
+
+```python
+from httpx_limiter.pyrate import PyrateAsyncLimiter
+
+# Single rate limit
+limiter = PyrateAsyncLimiter.create(Rate.create(magnitude=20))
+
+# Multiple rate limits
+limiter = PyrateAsyncLimiter.create(
+    Rate.create(magnitude=10),  # 10 per second
+    Rate.create(magnitude=100, duration=60),  # 100 per minute
+)
+```
+
+## Tutorial
+
+You can limit the number of requests made by an HTTPX client using the transports
+provided in this package. That is useful in situations when you need to make a large
+number of asynchronous requests against endpoints that implement a rate limit.
+
+### Single Rate Limit
+
+The simplest use case is to apply a single rate limit to all requests. If you want to be
+able to make twenty requests per second, for example, use the following code:
+
+```python
+import httpx
+from httpx_limiter import AsyncRateLimitedTransport, Rate
+from httpx_limiter.pyrate import PyrateAsyncLimiter
+
+async def main():
+    limiter = PyrateAsyncLimiter.create(Rate.create(magnitude=20))
+
+    async with httpx.AsyncClient(
+        transport=AsyncRateLimitedTransport.create(limiter=limiter),
+    ) as client:
+        response = await client.get("https://httpbin.org")
+```
+
+> [!IMPORTANT]
+> Due to limitations in the design of the underlying [leaky
+> bucket](https://en.wikipedia.org/wiki/Leaky_bucket) implementation, which is
+> used to implement the rate limiting, the magnitude of the rate is also the
+> maximum capacity of the bucket. That means, if you set a rate that is larger
+> than one, a burst of requests equal to that capacity will be allowed. If you
+> do not want to allow any bursts, set the magnitude to one, but the duration to
+> the inverse of your desired rate. If you want to allow twenty requests per
+> second, for example, set the magnitude to 1 and the duration to 0.05 seconds.
+>
+> ```python
+> Rate.create(magnitude=1, duration=1/20)
+> ```
+
+### Multiple Rate Limits
+
+For more advanced use cases, you can apply different rate limits based on a concrete
+implementation of the `AbstractRateLimiterRepository`. There are two relevant methods
+that both get passed the current request. One method needs to return an identifier for
+which rate limiter to choose, and the other method creates a rate limiter. See the
+following example:
+
+```python
+import httpx
+from httpx_limiter import (
+    AbstractRateLimiterRepository,
+    AsyncMultiRateLimitedTransport,
+    Rate
+)
+from httpx_limiter.aiolimiter import AiolimiterAsyncLimiter
+
+class DomainBasedRateLimiterRepository(AbstractRateLimiterRepository):
+    """Apply different rate limits based on the domain being requested."""
+
+    def get_identifier(self, request: httpx.Request) -> str:
+        """Return the domain as the identifier for rate limiting."""
+        return request.url.host
+
+    def create(self, request: httpx.Request) -> AiolimiterAsyncLimiter:
+        """Create a rate limiter for the domain."""
+        return AiolimiterAsyncLimiter.create(Rate.create(magnitude=25))
+
+client = httpx.AsyncClient(
+    transport=AsyncMultiRateLimitedTransport.create(
+        repository=DomainBasedRateLimiterRepository(),
+    ),
+)
+```
+
+> [!TIP]
+> You are free to ignore the request parameter and use global information like
+> the time of day to determine the rate limit.
+
+```python
+from datetime import datetime, timezone
+
+import httpx
+from httpx_limiter import AbstractRateLimiterRepository, Rate
+from httpx_limiter.pyrate import PyrateAsyncLimiter
+
+class DayNightRateLimiterRepository(AbstractRateLimiterRepository):
+    """Apply different rate limits based on the time of day."""
+
+    def get_identifier(self, request: httpx.Request) -> str:
+        """Identify whether it is currently day or night."""
+        if 6 <= datetime.now(tz=timezone.utc).hour < 18:
+            return "day"
+
+        return "night"
+
+    def create(self, request: httpx.Request) -> PyrateAsyncLimiter:
+        """Create a rate limiter based on the time of day."""
+        if self.get_identifier(request) == "day":
+            return PyrateAsyncLimiter.create(Rate.create(magnitude=10))
+
+        return PyrateAsyncLimiter.create(Rate.create(magnitude=100))
+```
+
+## Copyright
+
+-   Copyright © 2024, 2025 Moritz E. Beber.
+-   Free software distributed under the [Apache Software License 2.0](./LICENSE).

httpx_limiter-0.5.0/README.md

@@ -0,0 +1,181 @@
+# HTTPX Limiter
+
+|            |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
+| ---------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Package    | [![Latest PyPI Version](https://img.shields.io/pypi/v/httpx-limiter.svg)](https://pypi.org/project/httpx-limiter/) [![Supported Python Versions](https://img.shields.io/pypi/pyversions/httpx-limiter.svg)](https://pypi.org/project/httpx-limiter/)                                                                                                                                                                                                                                                                                                                                                 |
+| Meta       | [![Apache-2.0](https://img.shields.io/pypi/l/httpx-limiter.svg)](LICENSE) [![Code of Conduct](https://img.shields.io/badge/Contributor%20Covenant-v2.0%20adopted-ff69b4.svg)](.github/CODE_OF_CONDUCT.md) [![Checked with mypy](https://www.mypy-lang.org/static/mypy_badge.svg)](https://mypy-lang.org/) [![Code Style Black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/ambv/black) [![Linting: Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/charliermarsh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff) |
+| Automation | [![CI](https://github.com/Midnighter/httpx-limiter/actions/workflows/main.yml/badge.svg)](https://github.com/Midnighter/httpx-limiter/actions/workflows/main.yml)                                                                                                                                                                                                                                                                                                                                                                                                                                    |
+
+_A lightweight package that provides rate-limited httpx transports._
+
+## Installation
+
+The package is published on [PyPI](https://pypi.org/project/httpx-limiter/). Install it,
+for example, with the aiolimiter backend.
+
+```sh
+pip install 'httpx-limiter[aiolimiter]'
+```
+
+There is also a pyrate-limiter backend available.
+
+```sh
+pip install 'httpx-limiter[pyrate]'
+```
+
+## Rate Limiter Backends
+
+This package provides two different asynchronous rate limiter implementations to choose
+from:
+
+1. [aiolimiter](https://aiolimiter.readthedocs.io)
+2. [pyrate-limiter](https://pyratelimiter.readthedocs.io)
+
+> [!IMPORTANT]
+> While both implementations fulfill similar purposes, there are significant differences
+> between them. Please read the descriptions below to make an informed decision about
+> which one best suits your needs.
+
+### 1. aiolimiter
+
+-   **Single rate limit only**: Supports only one rate limit at a time
+-   **Lightweight**: Minimal dependencies and simpler configuration
+-   **Linear token refresh rate**: As an example, if you set a rate of 2 per second,
+    roughly one token will be added every 500 milliseconds
+
+```python
+from httpx_limiter.aiolimiter import AiolimiterAsyncLimiter
+
+limiter = AiolimiterAsyncLimiter.create(Rate.create(magnitude=20))
+```
+
+### 2. pyrate-limiter
+
+-   **Multiple rate limits**: Support for multiple concurrent rate limits, for example,
+    10 requests per second _and_ 100 requests per minute
+-   **Flexible configuration**: Comprehensive configuration options
+-   **Multiprocessing dependency**: Current implementation depends on `multiprocessing`
+    which may not be available in all environments, such as pyodide
+-   **Stepwise token refresh rate**: As an example, if you set a rate of 2 per second,
+    two token will be added every second
+
+```python
+from httpx_limiter.pyrate import PyrateAsyncLimiter
+
+# Single rate limit
+limiter = PyrateAsyncLimiter.create(Rate.create(magnitude=20))
+
+# Multiple rate limits
+limiter = PyrateAsyncLimiter.create(
+    Rate.create(magnitude=10),  # 10 per second
+    Rate.create(magnitude=100, duration=60),  # 100 per minute
+)
+```
+
+## Tutorial
+
+You can limit the number of requests made by an HTTPX client using the transports
+provided in this package. That is useful in situations when you need to make a large
+number of asynchronous requests against endpoints that implement a rate limit.
+
+### Single Rate Limit
+
+The simplest use case is to apply a single rate limit to all requests. If you want to be
+able to make twenty requests per second, for example, use the following code:
+
+```python
+import httpx
+from httpx_limiter import AsyncRateLimitedTransport, Rate
+from httpx_limiter.pyrate import PyrateAsyncLimiter
+
+async def main():
+    limiter = PyrateAsyncLimiter.create(Rate.create(magnitude=20))
+
+    async with httpx.AsyncClient(
+        transport=AsyncRateLimitedTransport.create(limiter=limiter),
+    ) as client:
+        response = await client.get("https://httpbin.org")
+```
+
+> [!IMPORTANT]
+> Due to limitations in the design of the underlying [leaky
+> bucket](https://en.wikipedia.org/wiki/Leaky_bucket) implementation, which is
+> used to implement the rate limiting, the magnitude of the rate is also the
+> maximum capacity of the bucket. That means, if you set a rate that is larger
+> than one, a burst of requests equal to that capacity will be allowed. If you
+> do not want to allow any bursts, set the magnitude to one, but the duration to
+> the inverse of your desired rate. If you want to allow twenty requests per
+> second, for example, set the magnitude to 1 and the duration to 0.05 seconds.
+>
+> ```python
+> Rate.create(magnitude=1, duration=1/20)
+> ```
+
+### Multiple Rate Limits
+
+For more advanced use cases, you can apply different rate limits based on a concrete
+implementation of the `AbstractRateLimiterRepository`. There are two relevant methods
+that both get passed the current request. One method needs to return an identifier for
+which rate limiter to choose, and the other method creates a rate limiter. See the
+following example:
+
+```python
+import httpx
+from httpx_limiter import (
+    AbstractRateLimiterRepository,
+    AsyncMultiRateLimitedTransport,
+    Rate
+)
+from httpx_limiter.aiolimiter import AiolimiterAsyncLimiter
+
+class DomainBasedRateLimiterRepository(AbstractRateLimiterRepository):
+    """Apply different rate limits based on the domain being requested."""
+
+    def get_identifier(self, request: httpx.Request) -> str:
+        """Return the domain as the identifier for rate limiting."""
+        return request.url.host
+
+    def create(self, request: httpx.Request) -> AiolimiterAsyncLimiter:
+        """Create a rate limiter for the domain."""
+        return AiolimiterAsyncLimiter.create(Rate.create(magnitude=25))
+
+client = httpx.AsyncClient(
+    transport=AsyncMultiRateLimitedTransport.create(
+        repository=DomainBasedRateLimiterRepository(),
+    ),
+)
+```
+
+> [!TIP]
+> You are free to ignore the request parameter and use global information like
+> the time of day to determine the rate limit.
+
+```python
+from datetime import datetime, timezone
+
+import httpx
+from httpx_limiter import AbstractRateLimiterRepository, Rate
+from httpx_limiter.pyrate import PyrateAsyncLimiter
+
+class DayNightRateLimiterRepository(AbstractRateLimiterRepository):
+    """Apply different rate limits based on the time of day."""
+
+    def get_identifier(self, request: httpx.Request) -> str:
+        """Identify whether it is currently day or night."""
+        if 6 <= datetime.now(tz=timezone.utc).hour < 18:
+            return "day"
+
+        return "night"
+
+    def create(self, request: httpx.Request) -> PyrateAsyncLimiter:
+        """Create a rate limiter based on the time of day."""
+        if self.get_identifier(request) == "day":
+            return PyrateAsyncLimiter.create(Rate.create(magnitude=10))
+
+        return PyrateAsyncLimiter.create(Rate.create(magnitude=100))
+```
+
+## Copyright
+
+-   Copyright © 2024, 2025 Moritz E. Beber.
+-   Free software distributed under the [Apache Software License 2.0](./LICENSE).

{httpx_limiter-0.3.0 → httpx_limiter-0.5.0}/pyproject.toml

@@ -14,11 +14,9 @@ requires = ["hatchling", "hatch-vcs"]
 name = "httpx-limiter"
 dynamic = ["version"]
 description = "A lightweight package that provides rate-limited httpx transports."
-authors = [
-    { name = "Moritz E. Beber", email = "midnighter@posteo.net" },
-]
+authors = [{ name = "Moritz E. Beber", email = "midnighter@posteo.net" }]
 license = "Apache-2.0"
-readme = {"file" = "README.md", "content-type" = "text/markdown"}
+readme = { "file" = "README.md", "content-type" = "text/markdown" }
 requires-python = ">=3.10"
 # Please consult https://pypi.org/classifiers/ for a full list.
 classifiers = [
@@ -37,15 +35,10 @@ classifiers = [
     "Topic :: Internet :: WWW/HTTP",
     "Typing :: Typed",
 ]
-keywords = [
-    "httpx",
-    "limiter",
-    "rate-limit",
-    "leaky bucket",
-]
+keywords = ["httpx", "limiter", "rate-limit", "leaky bucket"]
 dependencies = [
     "httpx ~=0.25",
-    "aiolimiter ~=1.2",
+    "typing-extensions ~=4.6; python_version < '3.11'",
 ]
 
 [project.urls]
@@ -55,6 +48,10 @@ Documentation = "https://httpx-limiter.readthedocs.io"
 "Bug Tracker" = "https://github.com/Midnighter/httpx-limiter/issues"
 Download = "https://pypi.org/project/httpx-limiter/#files"
 
+[project.optional-dependencies]
+aiolimiter = ["aiolimiter ~=1.2"]
+pyrate = ["pyrate-limiter ~=3.9"]
+
 ################################################################################
 # Tool Configuration
 ################################################################################
@@ -76,17 +73,12 @@ testpaths = ["tests"]
 markers = ["raises"]
 
 [tool.coverage.paths]
-source = [
-    "src/httpx_limiter",
-    "*/site-packages/httpx_limiter",
-]
+source = ["src/httpx_limiter", "*/site-packages/httpx_limiter"]
 
 [tool.coverage.run]
 branch = true
 parallel = true
-omit = [
-    "src/httpx_limiter/_version.py",
-]
+omit = ["src/httpx_limiter/_version.py"]
 
 [tool.coverage.report]
 exclude_lines = ["pragma: no cover"]
@@ -98,29 +90,31 @@ line-length = 88
 [tool.ruff.lint]
 select = ["ALL"]
 ignore = [
-    "D107",  # 'Missing docstring in __init__' ignored because pydoclint wants us to document the class instead.
-    "D203",  # '1 blank line required before class docstring' ignored because we want no blank line.
-    "D212",  # 'Multi-line docstring summary should start at the first line' ignored because we want the summary to start on the second line.
-    "D407",  # 'Missing dashed underline after section' ignored because Google style docstrings don't underline.
-    "ANN002",  # 'Missing type annotation for {*args} in method'.
-    "ANN003",  # 'Missing type annotation for {*kwargs} in method'.
-]
-exclude = [
-    "src/httpx_limiter/_version.py",
+    "D107",   # 'Missing docstring in __init__' ignored because pydoclint wants us to document the class instead.
+    "D203",   # '1 blank line required before class docstring' ignored because we want no blank line.
+    "D212",   # 'Multi-line docstring summary should start at the first line' ignored because we want the summary to start on the second line.
+    "D407",   # 'Missing dashed underline after section' ignored because Google style docstrings don't underline.
+    "ANN002", # 'Missing type annotation for {*args} in method'.
+    "ANN003", # 'Missing type annotation for {*kwargs} in method'.
 ]
+exclude = ["src/httpx_limiter/_version.py"]
 
 [tool.ruff.lint.extend-per-file-ignores]
 "__init__.py" = [
-    "E401",  # 'Multiple imports on one line'
-    "E402",  # 'Module level import not at top of file'
-    "F401",  # 'Imported but unused'
-    "I001",  # 'Import block is un-sorted or un-formatted' ignored because we may have to import in a particular, not-alphabetical order.
+    "E401", # 'Multiple imports on one line'
+    "E402", # 'Module level import not at top of file'
+    "F401", # 'Imported but unused'
+    "I001", # 'Import block is un-sorted or un-formatted' ignored because we may have to import in a particular, not-alphabetical order.
 ]
 "tests/**/*.py" = [
-    "S101",  # 'Use of assert detected' ignored because we are using pytest.
+    "S101",    # 'Use of assert detected' ignored because we are using pytest.
     "INP001",  # 'Insecure input' ignored because we are testing.
     "ANN201",  # 'Missing type annotation for {return}' ignored because all tests return `None`.
-    "PLR2004",  # Magic numbers are okay in tests.
+    "PLR2004", # Magic numbers are okay in tests.
+]
+"tests/pyodide/**/*.py" = [
+    "PLC0415", # We explicitly need imports inside function and ignore the '`import` should be at the top-level of a file' rule.
+    "I001",    # 'Import block is un-sorted or un-formatted' ignored because we may have to import in a particular, not-alphabetical order.
 ]
 
 [tool.ruff.lint.isort]
@@ -143,9 +137,7 @@ exclude = "_version.py"
 
 # Stop mypy from complaining about missing types from imports.
 [[tool.mypy.overrides]]
-module = [
-    "limiter",
-]
+module = ["limiter"]
 ignore_missing_imports = true
 
 #[tool.pydantic-mypy]
@@ -159,6 +151,7 @@ ignore_missing_imports = true
 
 [tool.hatch.envs.default]
 installer = "uv"
+features = ["aiolimiter", "pyrate"]
 
 [tool.hatch.envs.dev]
 description = """Development environment."""
@@ -170,12 +163,13 @@ extra-dependencies = [
     "ruff",
 ]
 
+[tool.hatch.envs.dev.env-vars]
+PYTHONDEVMODE = "1"
+PYTHONASYNCIODEBUG = "1"
+
 [tool.hatch.envs.style]
 description = """Check the style of the codebase."""
-dependencies = [
-    "pydoclint ~=0.6",
-    "ruff",
-]
+dependencies = ["pydoclint", "ruff"]
 detached = true
 installer = "uv"
 
@@ -187,18 +181,14 @@ check = ["docstrings", "code"]
 
 [tool.hatch.envs.audit]
 description = """Check dependencies for security vulnerabilities."""
-extra-dependencies = [
-    "pip-audit",
-]
+extra-dependencies = ["pip-audit"]
 
 [tool.hatch.envs.audit.scripts]
 check = ["pip-audit"]
 
 [tool.hatch.envs.types]
 description = """Check the static types of the codebase."""
-dependencies = [
-    "mypy",
-]
+extra-dependencies = ["mypy"]
 
 [tool.hatch.envs.types.scripts]
 check = "mypy src/httpx_limiter"
@@ -209,26 +199,23 @@ extra-dependencies = [
     "mkdocs-material ~=9.5",
     "mkdocstrings[python] ~=0.24",
     "mkdocs-awesome-pages-plugin ~=2.9",
+    "mike ~=2.1",
 ]
 
 [tool.hatch.envs.docs.scripts]
 build = "mkdocs build {args:--clean --strict}"
 serve = "mkdocs serve {args}"
+deploy = "mike deploy {args}"
 
-#[tool.hatch.envs.install]
-#description = """Test the installation the package."""
-#dependencies = [
-#    "pip",
-#    "twine",
-#]
-#detached = true
+[tool.hatch.envs.distribution]
+description = """Test the source and wheel distribution of the package."""
+dependencies = ["pip", "twine"]
+detached = true
+installer = "uv"
+builder = true
 
-#[tool.hatch.envs.install.scripts]
-#check = [
-#    "pip check",
-#    "hatch build {args:--clean}",
-#    "twine check dist/*",
-#]
+[tool.hatch.envs.distribution.scripts]
+check = ["pip check", "hatch build {args:--clean}", "twine check dist/*"]
 
 [tool.hatch.envs.unit-tests]
 description = """Run the unit tests."""
@@ -240,6 +227,10 @@ extra-dependencies = [
     "pytest-raises",
 ]
 
+[tool.hatch.envs.unit-tests.env-vars]
+PYTHONDEVMODE = "1"
+PYTHONASYNCIODEBUG = "1"
+
 [[tool.hatch.envs.unit-tests.matrix]]
 python = ["3.10", "3.11", "3.12", "3.13"]
 
@@ -256,6 +247,10 @@ extra-dependencies = [
     "pytest-raises",
 ]
 
+[tool.hatch.envs.acceptance-tests.env-vars]
+PYTHONDEVMODE = "1"
+PYTHONASYNCIODEBUG = "1"
+
 [[tool.hatch.envs.acceptance-tests.matrix]]
 python = ["3.10", "3.11", "3.12", "3.13"]
 

{httpx_limiter-0.3.0 → httpx_limiter-0.5.0}/src/httpx_limiter/__init__.py

@@ -15,7 +15,9 @@
 
 """Provide top level symbols."""
 
+from .types import HTTPXAsyncHTTPTransportKeywordArguments
 from .rate import Number, Rate
+from .abstract_async_limiter import AbstractAsyncLimiter
 from .async_rate_limited_transport import AsyncRateLimitedTransport
 from .abstract_rate_limiter_repository import AbstractRateLimiterRepository
 from .async_multi_rate_limited_transport import AsyncMultiRateLimitedTransport

{httpx_limiter-0.3.0 → httpx_limiter-0.5.0}/src/httpx_limiter/_version.py

@@ -1,7 +1,14 @@
 # file generated by setuptools-scm
 # don't change, don't track in version control
 
-__all__ = ["__version__", "__version_tuple__", "version", "version_tuple"]
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
 
 TYPE_CHECKING = False
 if TYPE_CHECKING:
@@ -9,13 +16,19 @@ if TYPE_CHECKING:
     from typing import Union
 
     VERSION_TUPLE = Tuple[Union[int, str], ...]
+    COMMIT_ID = Union[str, None]
 else:
     VERSION_TUPLE = object
+    COMMIT_ID = object
 
 version: str
 __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
+commit_id: COMMIT_ID
+__commit_id__: COMMIT_ID
 
-__version__ = version = '0.3.0'
-__version_tuple__ = version_tuple = (0, 3, 0)
+__version__ = version = '0.5.0'
+__version_tuple__ = version_tuple = (0, 5, 0)
+
+__commit_id__ = commit_id = None