# Steindamm
A library which regulates traffic, with respect to concurrency or time.
It implements sync and async context managers for a [semaphore](#semaphore)- and a [token bucket](#token-bucket)-implementation.
The rate limiters can be distributed using Redis, or run locally in-memory for single-process applications.
**Redis-based limiters** leverage Lua scripts on Redis, each operation is fully atomic.
Both standalone Redis instances and clusters are supported with sync and async interfaces.
**Local limiters** provide thread-safe (for sync) and asyncio-safe (for async) in-memory rate limiting without requiring Redis.
We currently support Python 3.11, 3.12, and 3.13.
## Features
### Deployment Options
- **Local (In-Memory)**: Thread-safe and asyncio-safe rate limiting without Redis dependencies
- Perfect for single-process applications, testing, and development
- Zero external dependencies required
- **Redis-Based**: Distributed rate limiting using Redis with Lua scripts
- Atomic operations for accuracy in distributed systems
- Supports both standalone Redis and Redis Cluster
- Scales across multiple processes and servers
### Async & Sync Support
- Full support for both synchronous and asynchronous code
- Context manager interface (`with` / `async with`)
### Flexibility & Control
- **Factory Classes**: `SyncTokenBucket` and `AsyncTokenBucket` automatically choose implementation based on connection
- **Explicit Classes**: Direct access to `SyncRedisTokenBucket`, `AsyncRedisTokenBucket`, `SyncLocalTokenBucket`, `AsyncLocalTokenBucket`
- **Configurable Token Consumption**: `tokens_to_consume` parameter for variable-cost operations
- **Customizable Behavior**: Control capacity, refill rates, expiry, max sleep time, and initial state
## Installation
### Basic Installation (Local limiters only)
```bash
pip install steindamm
```
### With Redis Support
```bash
pip install steindamm[redis]
```
Or install Redis separately:
```bash
pip install steindamm redis
```
## Usage
### Token bucket
The `TokenBucket` classes are useful if you're working with time-based
rate limits. Say, you are allowed 100 requests per minute, for a given API token.
If the `max_sleep` limit is exceeded, a `MaxSleepExceededError` is raised. Setting `max_sleep` to 0.0 will sleep "endlessly" - this is also the default value. On the other hand `expiry` is how long the token bucket will persist in Redis without any activity (acquires or releases). You might need to adjust both to your requirements.
#### Using Local (In-Memory) Token Bucket
The local token bucket doesn't require Redis and runs entirely in-memory.
Perfect for single-process applications or testing.
> **Note:** The local token bucket implementation does not currently support expiry of bucket state. Buckets persist in memory for the lifetime of the process. If you are creating buckets dynamically (e.g., one bucket per user or per API key), this could lead to unbounded memory growth. Consider using the Redis-based implementation for applications with dynamic bucket creation, or ensure buckets are reused for the same resources.
**Async version:**
```python
import asyncio
from httpx import AsyncClient
from steindamm import AsyncTokenBucket
# No Redis connection needed - runs in-memory
limiter = AsyncTokenBucket(
name="foo", # name of the resource you are limiting traffic for
capacity=5, # hold up to 5 tokens (default: 5.0)
refill_frequency=1, # add tokens every second (default: 1.0)
refill_amount=1, # add 1 token when refilling (default: 1.0)
initial_tokens=None, # start with full capacity (default: None, which uses capacity)
max_sleep=30, # raise an error if there are no free tokens for X seconds, 0 never expires (default: 30.0)
tokens_to_consume=1, # consume 1 token per request (default: 1.0)
)
async def get_foo():
async with AsyncClient() as client:
async with limiter:
await client.get(...)
async def main():
await asyncio.gather(
get_foo() for i in range(100)
)
```
**Sync version:**
```python
import requests
from steindamm import SyncTokenBucket
limiter = SyncTokenBucket(
name="foo",
capacity=5,
refill_frequency=1,
refill_amount=1,
tokens_to_consume=1,
)
def main():
with limiter:
requests.get(...)
```
#### Using Redis-Based Token Bucket
For distributed rate limiting across multiple processes or servers,
use the Redis-based implementation by providing a `connection` parameter.
**Async version:**
```python
import asyncio
from httpx import AsyncClient
from redis.asyncio import Redis
from steindamm import AsyncTokenBucket
# With Redis connection - distributed across processes/servers
limiter = AsyncTokenBucket(
connection=Redis.from_url("redis://localhost:6379"), # Add Redis connection for distributed limiting
name="foo",
capacity=5,
refill_frequency=1,
refill_amount=1,
max_sleep=30,
expiry=60, # set expiry on Redis keys in seconds (default: 60)
tokens_to_consume=1,
)
async def get_foo():
async with AsyncClient() as client:
async with limiter:
await client.get(...)
async def main():
await asyncio.gather(
get_foo() for i in range(100)
)
```
**Sync version:**
```python
import requests
from redis import Redis
from steindamm import SyncTokenBucket
limiter = SyncTokenBucket(
connection=Redis.from_url("redis://localhost:6379"),
name="foo",
capacity=5,
refill_frequency=1,
refill_amount=1,
max_sleep=30,
expiry=60,
tokens_to_consume=1,
)
def main():
with limiter:
requests.get(...)
```
### Semaphore
The semaphore classes are useful when you have concurrency restrictions;
e.g., say you're allowed 5 active requests at the time for a given API token.
**Note:** Currently, only Redis-based semaphores are available. Local (in-memory) semaphore implementation is planned for a future release.
Beware that the client will block until the Semaphore is acquired,
or the `max_sleep` limit is exceeded. If the `max_sleep` limit is exceeded, a `MaxSleepExceededError` is raised. Setting `max_sleep` to 0.0 will sleep "endlessly" - default is 30 seconds. On the other hand `expiry` is how long the semaphore will persist in Redis without any activity (acquires or releases). You might need to adjust both to your requirements.
Here's how you might use the async version:
```python
import asyncio
from httpx import AsyncClient
from redis.asyncio import Redis
from steindamm import AsyncSemaphore
# All properties have defaults except name and connection
limiter = AsyncSemaphore(
connection=Redis.from_url("redis://localhost:6379"),
name="foo", # name of the resource you are limiting traffic for
capacity=5, # allow 5 concurrent requests (default: 5)
max_sleep=30, # raise an error if it takes longer than 30 seconds to acquire the semaphore (default: 30.0)
expiry=60, # set expiry on the semaphore keys in Redis to prevent deadlocks (default: 60)
)
async def get_foo():
async with AsyncClient() as client:
async with limiter:
await client.get(...)
async def main():
await asyncio.gather(
get_foo() for i in range(100)
)
```
and here is how you might use the sync version:
```python
import requests
from redis import Redis
from steindamm import SyncSemaphore
limiter = SyncSemaphore(
connection=Redis.from_url("redis://localhost:6379"),
name="foo",
capacity=5,
max_sleep=30,
expiry=60,
)
def main():
with limiter:
requests.get(...)
```
#### Using Explicit Implementation Classes
For explicit control over which implementation to use, import the specific classes:
```python
# Local implementations
from steindamm import SyncLocalTokenBucket, AsyncLocalTokenBucket
# Redis implementations
from steindamm import SyncRedisTokenBucket, AsyncRedisTokenBucket
# Use directly without factory logic
local_limiter = SyncLocalTokenBucket(name="api", capacity=10)
redis_limiter = SyncRedisTokenBucket(connection=redis_conn, name="api", capacity=10)
```
#### Consuming Multiple Tokens Per Request
You can control how many tokens are consumed per operation using the `tokens_to_consume` parameter.
This is useful when different operations _on the same api_ have different "costs". Note, how the "name" aka is the same between the limiters which will cause the tokens to be shared.
```python
from steindamm import SyncTokenBucket
# Small requests consume 1 token
small_limiter = SyncTokenBucket(name="api", capacity=100, tokens_to_consume=1)
# Large requests consume 5 tokens
large_limiter = SyncTokenBucket(name="api", capacity=100, tokens_to_consume=5)
with small_limiter:
make_small_request() # Consumes 1 token
with large_limiter:
make_large_request() # Consumes 5 tokens
```
### Using them as a decorator
We don't ship decorators in the package, but if you would
like to limit the rate at which a whole function is run,
you can create your own, like this:
```python
from steindamm import AsyncSemaphore
from redis.asyncio import Redis
# Define a decorator function
def limit(name, capacity, connection):
def middle(f):
async def inner(*args, **kwargs):
async with AsyncSemaphore(connection=connection, name=name, capacity=capacity):
return await f(*args, **kwargs)
return inner
return middle
# Or for local token buckets (no Redis needed)
from steindamm import AsyncTokenBucket
def rate_limit(name, capacity):
def middle(f):
async def inner(*args, **kwargs):
async with AsyncTokenBucket(name=name, capacity=capacity):
return await f(*args, **kwargs)
return inner
return middle
# Then pass the relevant limiter arguments like this
@limit(name="foo", capacity=5, connection=Redis.from_url("redis://localhost:6379"))
async def fetch_foo(id: UUID) -> Foo:
...
# Or with local rate limiting
@rate_limit(name="bar", capacity=10)
async def fetch_bar(id: UUID) -> Bar:
...
```
## Contributing
Contributions are very welcome. Here's how to get started:
- Clone the repo
- Install [uv](https://docs.astral.sh/uv/getting-started/installation/) and [mise](https://mise.jdx.dev/)
- Run `mise run install` to install dependencies
If you prefer not to install mise, check the `mise.toml` file and
run the commands manually.
- Make your code changes, with tests
- Run tests with `mise run test` or `uv run pytest`
Note that you will need to first spin up the redis docker containers. This can be done with `mise run test-setup` (and shut down with `mise run test-teardown`) or the full cycle can be run with `mise run test-full`.
- Commit your changes and open a PR
## Publishing a new version
To publish a new version:
- Update the package version in the `pyproject.toml`
- Open [Github releases](https://github.com/Feuerstein-Org/steindamm/releases)
- Press "Draft a new release"
- Set a tag matching the new version (for example, `v0.8.0`)
- Set the title matching the tag
- Add some release notes, explaining what has changed
- Publish
Once the release is published, our [publish workflow](https://github.com/Feuerstein-Org/steindamm/blob/main/.github/workflows/publish.yaml) should be triggered
to push the new version to PyPI.
## Acknowledgment:
This project was initially forked from [redis-rate-limiters](https://github.com/otovo/redis-rate-limiters) and was mainly created by Sondre Lillebø Gundersen [link](https://github.com/sondrelg). It was no longer maintained and I since rewrote a lot of stuff as well as added a local version of the limiters and new functionality like the initial amount of tokens or how many tokens to consume at once.
Raw data
{
"_id": null,
"home_page": null,
"name": "steindamm",
"maintainer": null,
"docs_url": null,
"requires_python": ">=3.11",
"maintainer_email": null,
"keywords": "redis, async, sync, rate, limiting, limiters, token-bucket, semaphore",
"author": "Emil Aliyev, Sondre Lilleb\u00f8 Gundersen",
"author_email": "Emil Aliyev <ea01052002@gmail.com>, Sondre Lilleb\u00f8 Gundersen <sondrelg@live.no>",
"download_url": "https://files.pythonhosted.org/packages/13/2d/f41ea03361313792589274d8fac237c8b7af533f637db48daea19fccd3ae/steindamm-0.8.0.tar.gz",
"platform": null,
"description": "# Steindamm\n\nA library which regulates traffic, with respect to concurrency or time.\nIt implements sync and async context managers for a [semaphore](#semaphore)- and a [token bucket](#token-bucket)-implementation.\n\nThe rate limiters can be distributed using Redis, or run locally in-memory for single-process applications.\n\n**Redis-based limiters** leverage Lua scripts on Redis, each operation is fully atomic.\nBoth standalone Redis instances and clusters are supported with sync and async interfaces.\n\n**Local limiters** provide thread-safe (for sync) and asyncio-safe (for async) in-memory rate limiting without requiring Redis.\n\nWe currently support Python 3.11, 3.12, and 3.13.\n\n## Features\n\n### Deployment Options\n- **Local (In-Memory)**: Thread-safe and asyncio-safe rate limiting without Redis dependencies\n - Perfect for single-process applications, testing, and development\n - Zero external dependencies required\n- **Redis-Based**: Distributed rate limiting using Redis with Lua scripts\n - Atomic operations for accuracy in distributed systems\n - Supports both standalone Redis and Redis Cluster\n - Scales across multiple processes and servers\n\n### Async & Sync Support\n- Full support for both synchronous and asynchronous code\n- Context manager interface (`with` / `async with`)\n\n### Flexibility & Control\n- **Factory Classes**: `SyncTokenBucket` and `AsyncTokenBucket` automatically choose implementation based on connection\n- **Explicit Classes**: Direct access to `SyncRedisTokenBucket`, `AsyncRedisTokenBucket`, `SyncLocalTokenBucket`, `AsyncLocalTokenBucket`\n- **Configurable Token Consumption**: `tokens_to_consume` parameter for variable-cost operations\n- **Customizable Behavior**: Control capacity, refill rates, expiry, max sleep time, and initial state\n\n## Installation\n\n### Basic Installation (Local limiters only)\n```bash\npip install steindamm\n```\n\n### With Redis Support\n```bash\npip install steindamm[redis]\n```\nOr install Redis separately:\n```bash\npip install steindamm redis\n```\n\n## Usage\n\n### Token bucket\n\nThe `TokenBucket` classes are useful if you're working with time-based\nrate limits. Say, you are allowed 100 requests per minute, for a given API token.\n\nIf the `max_sleep` limit is exceeded, a `MaxSleepExceededError` is raised. Setting `max_sleep` to 0.0 will sleep \"endlessly\" - this is also the default value. On the other hand `expiry` is how long the token bucket will persist in Redis without any activity (acquires or releases). You might need to adjust both to your requirements.\n\n#### Using Local (In-Memory) Token Bucket\n\nThe local token bucket doesn't require Redis and runs entirely in-memory.\nPerfect for single-process applications or testing.\n\n> **Note:** The local token bucket implementation does not currently support expiry of bucket state. Buckets persist in memory for the lifetime of the process. If you are creating buckets dynamically (e.g., one bucket per user or per API key), this could lead to unbounded memory growth. Consider using the Redis-based implementation for applications with dynamic bucket creation, or ensure buckets are reused for the same resources.\n\n**Async version:**\n\n```python\nimport asyncio\n\nfrom httpx import AsyncClient\n\nfrom steindamm import AsyncTokenBucket\n\n# No Redis connection needed - runs in-memory\nlimiter = AsyncTokenBucket(\n name=\"foo\", # name of the resource you are limiting traffic for\n capacity=5, # hold up to 5 tokens (default: 5.0)\n refill_frequency=1, # add tokens every second (default: 1.0)\n refill_amount=1, # add 1 token when refilling (default: 1.0)\n initial_tokens=None, # start with full capacity (default: None, which uses capacity)\n max_sleep=30, # raise an error if there are no free tokens for X seconds, 0 never expires (default: 30.0)\n tokens_to_consume=1, # consume 1 token per request (default: 1.0)\n)\n\nasync def get_foo():\n async with AsyncClient() as client:\n async with limiter:\n await client.get(...)\n\nasync def main():\n await asyncio.gather(\n get_foo() for i in range(100)\n )\n```\n\n**Sync version:**\n\n```python\nimport requests\n\nfrom steindamm import SyncTokenBucket\n\nlimiter = SyncTokenBucket(\n name=\"foo\",\n capacity=5,\n refill_frequency=1,\n refill_amount=1,\n tokens_to_consume=1,\n)\n\ndef main():\n with limiter:\n requests.get(...)\n```\n\n#### Using Redis-Based Token Bucket\n\nFor distributed rate limiting across multiple processes or servers,\nuse the Redis-based implementation by providing a `connection` parameter.\n\n**Async version:**\n\n```python\nimport asyncio\n\nfrom httpx import AsyncClient\nfrom redis.asyncio import Redis\n\nfrom steindamm import AsyncTokenBucket\n\n# With Redis connection - distributed across processes/servers\nlimiter = AsyncTokenBucket(\n connection=Redis.from_url(\"redis://localhost:6379\"), # Add Redis connection for distributed limiting\n name=\"foo\",\n capacity=5,\n refill_frequency=1,\n refill_amount=1,\n max_sleep=30,\n expiry=60, # set expiry on Redis keys in seconds (default: 60)\n tokens_to_consume=1,\n)\n\nasync def get_foo():\n async with AsyncClient() as client:\n async with limiter:\n await client.get(...)\n\nasync def main():\n await asyncio.gather(\n get_foo() for i in range(100)\n )\n```\n\n**Sync version:**\n\n```python\nimport requests\nfrom redis import Redis\n\nfrom steindamm import SyncTokenBucket\n\n\nlimiter = SyncTokenBucket(\n connection=Redis.from_url(\"redis://localhost:6379\"),\n name=\"foo\",\n capacity=5,\n refill_frequency=1,\n refill_amount=1,\n max_sleep=30,\n expiry=60,\n tokens_to_consume=1,\n)\n\ndef main():\n with limiter:\n requests.get(...)\n```\n\n### Semaphore\n\nThe semaphore classes are useful when you have concurrency restrictions;\ne.g., say you're allowed 5 active requests at the time for a given API token.\n\n**Note:** Currently, only Redis-based semaphores are available. Local (in-memory) semaphore implementation is planned for a future release.\n\nBeware that the client will block until the Semaphore is acquired,\nor the `max_sleep` limit is exceeded. If the `max_sleep` limit is exceeded, a `MaxSleepExceededError` is raised. Setting `max_sleep` to 0.0 will sleep \"endlessly\" - default is 30 seconds. On the other hand `expiry` is how long the semaphore will persist in Redis without any activity (acquires or releases). You might need to adjust both to your requirements.\n\nHere's how you might use the async version:\n\n```python\nimport asyncio\n\nfrom httpx import AsyncClient\nfrom redis.asyncio import Redis\n\nfrom steindamm import AsyncSemaphore\n\n# All properties have defaults except name and connection\nlimiter = AsyncSemaphore(\n connection=Redis.from_url(\"redis://localhost:6379\"),\n name=\"foo\", # name of the resource you are limiting traffic for\n capacity=5, # allow 5 concurrent requests (default: 5)\n max_sleep=30, # raise an error if it takes longer than 30 seconds to acquire the semaphore (default: 30.0)\n expiry=60, # set expiry on the semaphore keys in Redis to prevent deadlocks (default: 60)\n)\n\nasync def get_foo():\n async with AsyncClient() as client:\n async with limiter:\n await client.get(...)\n\n\nasync def main():\n await asyncio.gather(\n get_foo() for i in range(100)\n )\n```\n\nand here is how you might use the sync version:\n\n```python\nimport requests\nfrom redis import Redis\n\nfrom steindamm import SyncSemaphore\n\n\nlimiter = SyncSemaphore(\n connection=Redis.from_url(\"redis://localhost:6379\"),\n name=\"foo\",\n capacity=5,\n max_sleep=30,\n expiry=60,\n)\n\ndef main():\n with limiter:\n requests.get(...)\n```\n\n#### Using Explicit Implementation Classes\n\nFor explicit control over which implementation to use, import the specific classes:\n\n```python\n# Local implementations\nfrom steindamm import SyncLocalTokenBucket, AsyncLocalTokenBucket\n\n# Redis implementations\nfrom steindamm import SyncRedisTokenBucket, AsyncRedisTokenBucket\n\n# Use directly without factory logic\nlocal_limiter = SyncLocalTokenBucket(name=\"api\", capacity=10)\nredis_limiter = SyncRedisTokenBucket(connection=redis_conn, name=\"api\", capacity=10)\n```\n\n#### Consuming Multiple Tokens Per Request\n\nYou can control how many tokens are consumed per operation using the `tokens_to_consume` parameter.\nThis is useful when different operations _on the same api_ have different \"costs\". Note, how the \"name\" aka is the same between the limiters which will cause the tokens to be shared.\n\n```python\nfrom steindamm import SyncTokenBucket\n\n# Small requests consume 1 token\nsmall_limiter = SyncTokenBucket(name=\"api\", capacity=100, tokens_to_consume=1)\n\n# Large requests consume 5 tokens\nlarge_limiter = SyncTokenBucket(name=\"api\", capacity=100, tokens_to_consume=5)\n\nwith small_limiter:\n make_small_request() # Consumes 1 token\n\nwith large_limiter:\n make_large_request() # Consumes 5 tokens\n```\n\n### Using them as a decorator\n\nWe don't ship decorators in the package, but if you would\nlike to limit the rate at which a whole function is run,\nyou can create your own, like this:\n\n```python\nfrom steindamm import AsyncSemaphore\nfrom redis.asyncio import Redis\n\n# Define a decorator function\ndef limit(name, capacity, connection):\n def middle(f):\n async def inner(*args, **kwargs):\n async with AsyncSemaphore(connection=connection, name=name, capacity=capacity):\n return await f(*args, **kwargs)\n return inner\n return middle\n\n# Or for local token buckets (no Redis needed)\nfrom steindamm import AsyncTokenBucket\n\ndef rate_limit(name, capacity):\n def middle(f):\n async def inner(*args, **kwargs):\n async with AsyncTokenBucket(name=name, capacity=capacity):\n return await f(*args, **kwargs)\n return inner\n return middle\n\n\n# Then pass the relevant limiter arguments like this\n@limit(name=\"foo\", capacity=5, connection=Redis.from_url(\"redis://localhost:6379\"))\nasync def fetch_foo(id: UUID) -> Foo:\n ...\n\n# Or with local rate limiting\n@rate_limit(name=\"bar\", capacity=10)\nasync def fetch_bar(id: UUID) -> Bar:\n ...\n```\n\n## Contributing\n\nContributions are very welcome. Here's how to get started:\n\n- Clone the repo\n- Install [uv](https://docs.astral.sh/uv/getting-started/installation/) and [mise](https://mise.jdx.dev/)\n- Run `mise run install` to install dependencies\n If you prefer not to install mise, check the `mise.toml` file and\n run the commands manually.\n- Make your code changes, with tests\n- Run tests with `mise run test` or `uv run pytest`\n Note that you will need to first spin up the redis docker containers. This can be done with `mise run test-setup` (and shut down with `mise run test-teardown`) or the full cycle can be run with `mise run test-full`.\n- Commit your changes and open a PR\n\n## Publishing a new version\n\nTo publish a new version:\n\n- Update the package version in the `pyproject.toml`\n- Open [Github releases](https://github.com/Feuerstein-Org/steindamm/releases)\n- Press \"Draft a new release\"\n- Set a tag matching the new version (for example, `v0.8.0`)\n- Set the title matching the tag\n- Add some release notes, explaining what has changed\n- Publish\n\nOnce the release is published, our [publish workflow](https://github.com/Feuerstein-Org/steindamm/blob/main/.github/workflows/publish.yaml) should be triggered\nto push the new version to PyPI.\n\n## Acknowledgment:\nThis project was initially forked from [redis-rate-limiters](https://github.com/otovo/redis-rate-limiters) and was mainly created by Sondre Lilleb\u00f8 Gundersen [link](https://github.com/sondrelg). It was no longer maintained and I since rewrote a lot of stuff as well as added a local version of the limiters and new functionality like the initial amount of tokens or how many tokens to consume at once.\n",
"bugtrack_url": null,
"license": null,
"summary": "Distributed token bucket and semphore",
"version": "0.8.0",
"project_urls": {
"Homepage": "https://github.com/Feuerstein-Org/steindamm",
"Repository": "https://github.com/Feuerstein-Org/steindamm"
},
"split_keywords": [
"redis",
" async",
" sync",
" rate",
" limiting",
" limiters",
" token-bucket",
" semaphore"
],
"urls": [
{
"comment_text": null,
"digests": {
"blake2b_256": "caa529cb0adde5b424873b619a7e277ce5750e411102150804b742c8378790cd",
"md5": "8c3feb34d8c404943c83e5b6f71c56e5",
"sha256": "400551074137193ef66582c7e870457ba07c877b144688b2ea21d660fb7c8c40"
},
"downloads": -1,
"filename": "steindamm-0.8.0-py3-none-any.whl",
"has_sig": false,
"md5_digest": "8c3feb34d8c404943c83e5b6f71c56e5",
"packagetype": "bdist_wheel",
"python_version": "py3",
"requires_python": ">=3.11",
"size": 17580,
"upload_time": "2025-10-27T05:54:22",
"upload_time_iso_8601": "2025-10-27T05:54:22.030804Z",
"url": "https://files.pythonhosted.org/packages/ca/a5/29cb0adde5b424873b619a7e277ce5750e411102150804b742c8378790cd/steindamm-0.8.0-py3-none-any.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": null,
"digests": {
"blake2b_256": "132df41ea03361313792589274d8fac237c8b7af533f637db48daea19fccd3ae",
"md5": "ccbaf797c9064c9189642345afb059a8",
"sha256": "031d74227a1cdd3bcf16fa23ec9077cdf0965ba8ccfdd14d9481b017819f9f79"
},
"downloads": -1,
"filename": "steindamm-0.8.0.tar.gz",
"has_sig": false,
"md5_digest": "ccbaf797c9064c9189642345afb059a8",
"packagetype": "sdist",
"python_version": "source",
"requires_python": ">=3.11",
"size": 13202,
"upload_time": "2025-10-27T05:54:22",
"upload_time_iso_8601": "2025-10-27T05:54:22.910413Z",
"url": "https://files.pythonhosted.org/packages/13/2d/f41ea03361313792589274d8fac237c8b7af533f637db48daea19fccd3ae/steindamm-0.8.0.tar.gz",
"yanked": false,
"yanked_reason": null
}
],
"upload_time": "2025-10-27 05:54:22",
"github": true,
"gitlab": false,
"bitbucket": false,
"codeberg": false,
"github_user": "Feuerstein-Org",
"github_project": "steindamm",
"travis_ci": false,
"coveralls": false,
"github_actions": true,
"lcname": "steindamm"
}
JSON
