Kurd MCP

PyPI Python License: MIT CI

Kurd is a high-performance Model Context Protocol (MCP) gateway for Python, powered by Rust.

The Rust data plane handles HTTP serving, JSON-RPC dispatch, tool routing, upstream aggregation, caching, retries, circuit breaking, backpressure, rate limiting, and Prometheus metrics. The Python layer provides the developer API — tool registration, runtime configuration, and an optional enterprise feature set.

Targets MCP protocol revision 2026-07-28. Fully typed (PEP 561).

Contents

Installation

pip install kurd

Requires Python 3.10+ and a 64-bit platform. Pre-built wheels are available for Windows, Linux (x86-64, aarch64), and macOS (x86-64, Apple Silicon).

Quick Start

from kurd import Router
from kurd._kurd import start_http_gateway

router = Router()

@router.tool()
async def add(a: int, b: int) -> int:
    """Add two integers."""
    return a + b

# Blocks until stop_http_gateway() is called or the process exits.
start_http_gateway("0.0.0.0:9200")

The gateway starts three endpoints:

Path Method Purpose
/mcp POST JSON-RPC 2.0 MCP endpoint
/health GET Liveness probe — returns 200 OK
/status GET Runtime, cache, upstream, and circuit-breaker snapshot
/metrics GET Prometheus metrics

Call the gateway:

curl -s http://localhost:9200/mcp \
  -H 'Content-Type: application/json' \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"add","arguments":{"a":3,"b":4}}}'

{"jsonrpc":"2.0","id":1,"result":{"resultType":"complete","content":[{"type":"text","text":"7"}],"isError":false}}

CLI

Kurd ships a kurd command installed alongside the package.

Usage: kurd <COMMAND>

Commands:
  serve   Start the HTTP MCP gateway

Options:
  -h, --help  Show this message and exit

kurd serve

kurd serve [--host HOST] [--port PORT] [--token TOKEN]
Flag Default Description
--host 0.0.0.0 Bind address
--port 8000 Bind port
--token — Bearer token for authentication (overrides KURD_AUTH_TOKEN) 
# Start on port 8000 with no authentication
kurd serve

# Start on a specific address with a bearer token
kurd serve --host 127.0.0.1 --port 9200 --token my-secret

# Use an environment variable for the token
KURD_AUTH_TOKEN=my-secret kurd serve --port 9200

Registering Tools

Decorator API

from kurd import Router

router = Router()

@router.tool()
async def search(query: str, limit: int = 10) -> list[str]:
    """Search the knowledge base."""
    return [f"result {i}" for i in range(limit)]

Type annotations are converted to a JSON Schema inputSchema automatically:

Python type JSON Schema type
int integer
float number
bool boolean
str string
list[T] array with item schema
dict object
Optional[T] / T | None schema of T

Parameters with defaults become optional; parameters without defaults are added to required.

Hot-reloading

Replace a tool's implementation at runtime without restarting the gateway:

router.reload_tool("search", new_search_function)

Unregistering

router.unregister_tool("search")

Introspection

router.list_tools()      # -> ["add", "search", ...]
router.list_upstreams()  # -> [("github", "http://..."), ...]

Mounting Upstream Servers

Kurd aggregates remote MCP servers alongside local tools.

router.mount("github", "http://github-mcp.internal:9300")
router.mount("jira",   "http://jira-mcp.internal:9300")

Upstream tools are prefixed with the upstream name:

github.create_issue
jira.create_ticket

Clients discover all tools — local and upstream — through a single tools/list call. Kurd fetches remote tool lists concurrently, caches them with a configurable TTL, and follows pagination automatically.

Unmounting and cache invalidation

router.unmount("github")   # stop routing to this upstream
router.refresh_tools()     # expire the tool list cache immediately

Upstream behaviour

  • Connection pool: persistent HTTP/1.1 connections via Reqwest
  • Retry: up to 3 attempts with exponential backoff + jitter
  • Circuit breaker: opens after 5 consecutive failures; resets after 30 s
  • Timeout: configurable per RuntimeConfig.upstream_timeout_ms
  • Private-network policy: loopback/private URLs blocked by default unless set_allow_private_upstreams(True) is called

Runtime Configuration

All gateway tunables are collected in RuntimeConfig:

from kurd import Router, RuntimeConfig

router = Router()
router.configure_runtime(RuntimeConfig(
    # Concurrency
    global_concurrency   = 512,   # max simultaneous in-flight requests
    upstream_concurrency = 64,    # max simultaneous upstream calls
    python_concurrency   = 64,    # max simultaneous Python tool calls
    upstream_timeout_ms  = 30_000,

    # Logging
    request_logging      = False, # structured per-request log lines

    # Rate limiting
    rate_limiting_enabled   = True,
    rate_limit_per_ip_rps   = 1_000,
    rate_limit_global_rps   = 10_000,

    # IP allowlist (None = allow all)
    ip_allowlist         = ["192.168.1.0/24", "10.0.0.1"],

    # Tool cache
    tools_cache_ttl_ms   = 30_000,

    # Enterprise (all off by default)
    enable_dlq                  = False,
    enable_idempotency          = False,
    secrets_backend             = "env",
    enable_webhooks             = False,
    enable_distributed_state    = False,
    distributed_state_backend   = "memory",
    redis_url                   = "redis://localhost:6379/0",
    enable_distributed_tracing  = False,
))

configure_runtime also accepts keyword arguments directly for ergonomic one-liners:

router.configure_runtime(request_logging=True, rate_limiting_enabled=True)

Runtime status

status = router.runtime_status()
# {
#   "global_active": 3,
#   "global_limit": 512,
#   "python_active": 1,
#   "upstream_metrics": {...},
#   "cache": {"hits": 142, "misses": 3},
#   ...
# }

Security

Bearer token authentication

Set a bearer token before starting the gateway. Requests missing or carrying a wrong token receive 401 Unauthorized.

from kurd._kurd import set_http_bearer_token, clear_http_bearer_token

set_http_bearer_token("my-production-token")
# clear_http_bearer_token()  # disable authentication

Via environment variable (loaded automatically at gateway start):

KURD_AUTH_TOKEN=my-production-token kurd serve

Tokens are compared with a constant-time byte comparison to prevent timing attacks.

IP allowlist

from kurd import set_ip_allowlist, clear_ip_allowlist

set_ip_allowlist(["10.0.0.1", "10.0.0.2"])
clear_ip_allowlist()  # allow all IPs again

Or through RuntimeConfig.ip_allowlist. Blocked IPs receive 403 Forbidden.

Rate limiting

router.configure_runtime(
    rate_limiting_enabled=True,
    rate_limit_per_ip_rps=1_000,
    rate_limit_global_rps=10_000,
)

Rate-limited requests receive 429 Too Many Requests with a Retry-After: 1 header and a retryAfterMs field in the JSON-RPC error body.

Additional safeguards

Safeguard Details
Request size cap 1 MiB hard limit; 413 on excess
Content-type validation Must be application/json; -32600 otherwise
Upstream URL validation Rejects credentials, fragments, and unsupported schemes
Private-network policy Upstream calls to loopback/RFC1918 blocked by default
CORS OPTIONS /mcp returns correct preflight headers; POST responses include Access-Control-Allow-Origin: *
Overload rejection 503 when global concurrency limit is reached

For internet-facing deployments, terminate TLS at a reverse proxy (nginx, Caddy, AWS ALB) and apply network-level controls there.

Observability

Structured logging

Enable per-request log lines (goes to stdout in the format chosen by KURD_LOG):

router.configure_runtime(request_logging=True)

Control log verbosity via environment variable:

KURD_LOG=kurd=debug kurd serve   # debug, info, warn, error
RUST_LOG=info kurd serve         # fallback if KURD_LOG is unset

Log level can also be changed at runtime via the logging/setLevel MCP method.

Prometheus metrics

curl http://localhost:9200/metrics
Metric Type Description
kurd_requests_total{status} counter Total requests by status (total, completed, rejected)
kurd_requests_active gauge In-flight requests right now
kurd_requests_peak_active gauge Highest concurrent request count since startup
kurd_request_latency_ms gauge Rolling average latency (ms)
kurd_request_latency_histogram_ms_bucket{le} histogram Latency distribution (1ms … 5000ms + Inf)
kurd_request_latency_histogram_ms_count counter Total completed requests counted in histogram
kurd_request_latency_histogram_ms_sum counter Total latency (ms) summed across all requests
kurd_python_active_calls gauge Active Python tool invocations
kurd_python_peak_active_calls gauge Peak simultaneous Python tool invocations
kurd_python_rejections_total counter Python tool calls dropped due to concurrency limit
kurd_upstream_requests_total{upstream} counter Requests forwarded per upstream
kurd_upstream_successes_total{upstream} counter Successful upstream calls
kurd_upstream_failures_total{upstream} counter Failed upstream calls
kurd_upstream_retries_total{upstream} counter Retry attempts per upstream
kurd_upstream_latency_ms{upstream} gauge Average upstream round-trip latency
kurd_upstream_circuit_breaker_state{upstream} gauge 0 = closed, 1 = open
kurd_upstream_active_calls{upstream} gauge Current in-flight calls per upstream
kurd_upstream_peak_active_calls{upstream} gauge Peak in-flight calls per upstream
kurd_upstream_rejections_total counter Upstream calls dropped due to concurrency limit
kurd_cache_hits_total counter Tool-list cache hits
kurd_cache_misses_total counter Tool-list cache misses
kurd_cache_invalidations_total counter Cache invalidations (manual or TTL expiry)
kurd_concurrency_limit{type} gauge Configured limits: global, upstream, python

Prometheus scrape config

# prometheus.yml
scrape_configs:
  - job_name: kurd
    static_configs:
      - targets: ["localhost:9200"]
    metrics_path: /metrics
    scrape_interval: 15s

Datadog

# datadog.yaml
instances:
  - openmetrics_endpoint: http://localhost:9200/metrics
    namespace: kurd
    metrics: ["kurd_.*"]

OpenTelemetry

from kurd.telemetry import setup_otel, OTELConfig

setup_otel(OTELConfig(
    service_name    = "my-gateway",
    otlp_endpoint   = "http://otel-collector:4317",
    sample_rate     = 1.0,
))

OTELConfig.service_version defaults to the installed kurd package version automatically.

Health checks

from kurd.health_checks import HealthCheckManager

hc = HealthCheckManager()

# Register a custom check
async def check_db():
    ...

hc.register_check("database", check_db, critical=True)

# Kubernetes probes
readiness = await hc.check_readiness()  # all critical checks pass
liveness  = await hc.check_liveness()   # process is running and active

MCP Protocol Compliance

Kurd implements the MCP 2026-07-28 protocol revision.

Supported methods

Method Behaviour
initialize Returns protocolVersion, capabilities, and serverInfo
ping Returns {}
server/discover Returns capabilities, supported versions, and server identity
tools/list Aggregates local + upstream tools; supports cursor-based pagination
tools/call Routes to local Python tool or upstream server
resources/list Returns empty list with ttlMs and cacheScope
resources/read Returns {"contents": []}
prompts/list Returns empty list with ttlMs and cacheScope
prompts/get Returns -32602 (gateway holds no prompts)
completion/complete Returns {"values": [], "hasMore": false}
logging/setLevel Applies log level to the tracing filter at runtime
notifications/* Accepted silently — returns 202 Accepted with empty body

Modern HTTP headers

When a client sends Mcp-Protocol-Version: 2026-07-28, Kurd additionally validates:

  • Mcp-Method header matches the JSON-RPC method field
  • Mcp-Name header matches params.name for tools/call

Mismatched headers return -32020. Unsupported protocol versions return -32019.

Enterprise Features

Enable features through RuntimeConfig or by importing the relevant manager class directly.

Multi-tenancy

from kurd.multitenancy import TenantManager

manager = TenantManager()
api_key = manager.add_tenant(
    tenant_id="acme",
    name="Acme Corp",
    quota_rps=100,
    allowed_tools=["add", "search"],
)

Each tenant receives a unique API key. Quotas and tool ACLs are enforced independently.

Billing

from kurd.billing import BillingManager

billing = BillingManager()
billing.set_pricing({"add": {"per_call": 0.001, "per_latency_ms": 0.0001}})
billing.track_call(tenant_id="acme", tool_name="add", latency_ms=12.5, success=True)

report = billing.get_usage_report("acme", period="2026-08")

Supported models: per-request, per-latency, tiered, hybrid.

Request idempotency

router.configure_runtime(enable_idempotency=True)
mgr = router.get_idempotency()

is_dup, cached = mgr.check_idempotent_key("req-abc-123", tenant_id="acme")
if is_dup:
    return cached

result = run_tool()
mgr.store_result("req-abc-123", "acme", result)

Backed by SQLite with a 24-hour TTL.

Dead-letter queue

router.configure_runtime(enable_dlq=True, dlq_storage_path="/data/kurd/dlq")
dlq = router.get_dlq()

dlq.add_message(request_id="req-123", tenant_id="acme",
                tool_name="add", arguments={"a":1,"b":2}, error="timeout")

dlq.register_replay_handler("add", handler)
success, error = dlq.replay_message("dlq_abc123")

stats = dlq.get_statistics(tenant_id="acme")
dlq.cleanup_archived(days=30)

Replay uses exponential backoff up to 1 hour.

Secrets management

from kurd.secrets_management import SecretsManager

# Kubernetes in-cluster | HashiCorp Vault | AWS Secrets Manager | env (default)
manager = SecretsManager(backend="vault",
                          vault_addr="https://vault.example.com",
                          vault_token="s.xxxxx")

secret = manager.get_secret("db_password")

Third-party dependencies (kubernetes, hvac, boto3) are imported lazily — only when the matching backend is activated.

Webhooks

router.configure_runtime(enable_webhooks=True)
hooks = router.get_webhooks()

hooks.register_webhook(
    url="https://example.com/hooks",
    events=["error", "rate_limit_exceeded"],
    tenant_id="acme",
)

Deliveries are HMAC-SHA256 signed and logged for audit via get_deliveries().

Distributed state

router.configure_runtime(
    enable_distributed_state=True,
    distributed_state_backend="redis",
    redis_url="redis://localhost:6379/0",
)
state = router.get_distributed_state()
state.set("gateway:version", 42)
state.increment("counters:acme:calls")

Use backend="memory" for single-instance deployments.

Distributed tracing

from kurd.distributed_tracing import extract_context

trace = extract_context(incoming_headers)
span  = trace.create_span("tool_execution", {"tool": "add"})
span.set_attribute("result", 42)
span.end()

Follows W3C Trace Context. Tracing state is available in router.runtime_status() when enabled.

Performance

Benchmarks from a Windows development machine (Python 3.12, release build):

Scenario Concurrency Throughput p50 p95 p99 Errors
Local Python tool 10 594.5 req/s 14.9 ms 23.9 ms 28.7 ms 0%
Local Python tool 50 587.9 req/s 33.3 ms 87.8 ms 119.1 ms 0%
Local Python tool 100 556.0 req/s 18.3 ms 29.5 ms 32.4 ms 0%
Upstream tool 10 412.2 req/s 21.8 ms 36.4 ms 42.7 ms 0%
Upstream tool 50 229.8 req/s 20.6 ms 534.6 ms 549.3 ms 0%
Sustained burst 100 573.3 req/s 73.5 ms 179.1 ms 218.5 ms 0%

Results depend on hardware, OS, Python version, and network conditions.

python -m pytest tests/test_load.py -q -s

Architecture

Python application
       │
       ▼
  kurd.Router                      ← Python API layer
       │
       ├── Enterprise modules (optional, lazy)
       │   multitenancy · billing · idempotency · DLQ
       │   secrets · webhooks · distributed state · tracing
       │
       ▼
   PyO3 boundary
       │
       ▼
  Rust MCP gateway (Axum + Tokio)
       │
       ├── HTTP handler  ─────────────────────────────────┐
       │   content-type · auth · IP allowlist              │
       │   rate limiting · concurrency backpressure        │
       │   CORS · request ID · tracing                     │
       │                                                   │
       ├── MCP dispatcher                                  │
       │   initialize · ping · server/discover             │
       │   tools/list (paginated) · tools/call             │
       │   resources · prompts · completion · logging      │
       │   notifications (202)                             │
       │                                                   │
       ├── Local Python tools ◄── PyO3 callback            │
       │   (Rayon-parallel batch parsing)                  │
       │                                                   │
       └── Upstream MCP servers                           │
           retry · circuit breaker · cache · metrics      ◄┘

The Rust layer holds all mutable gateway state in lock-free atomics and RwLock-guarded maps. Python code never touches the hot path after registration.

Development

Prerequisites

  • Rust stable toolchain (rustup update stable)
  • Python 3.10+
  • maturin and pytest
pip install maturin pytest

Build

# Development build (fast iteration)
maturin develop

# Optimised build (benchmarks, pre-release testing)
maturin develop --release

# Release wheel
maturin build --release

Test

python -m pytest -q

The test suite covers:

  • JSON-RPC parsing and fast batch parsing (Rayon)
  • Local sync and async tools
  • initialize handshake and lifecycle methods
  • tools/list pagination
  • completion/complete, notifications/202, CORS preflight
  • Upstream discovery, routing, and concurrency
  • Circuit breaker, retry, and timeout behaviour
  • Tool-list cache hits, misses, and invalidation
  • Bearer authentication (accepted and rejected)
  • IP allowlist enforcement
  • Rate-limit rejection and Retry-After header
  • Request-size and content-type guards
  • Prometheus metrics output
  • Load and burst behaviour

Linting

cargo check
cargo clippy -- -D warnings

Environment variables

Variable Purpose
KURD_AUTH_TOKEN Bearer token loaded automatically at gateway start
KURD_LOG Tracing filter (e.g. kurd=debug). Takes precedence over RUST_LOG
RUST_LOG Standard Rust log filter fallback

Project Structure

kurd-mcp/
├── kurd/
│   ├── __init__.py            # Public API + __version__
│   ├── py.typed               # PEP 561 marker
│   ├── cli.py                 # `kurd serve` entry point
│   ├── router.py              # Router class + RuntimeConfig
│   ├── telemetry.py           # OpenTelemetry integration
│   ├── health_checks.py       # Readiness and liveness probes
│   ├── authorization.py       # RBAC helpers
│   ├── multitenancy.py
│   ├── billing.py
│   ├── idempotency.py
│   ├── dead_letter_queue.py
│   ├── secrets_management.py
│   ├── webhooks.py
│   ├── distributed_state.py
│   ├── distributed_tracing.py
│   └── ...
├── src/
│   └── lib.rs                 # Rust data plane (~2600 lines)
├── tests/
│   ├── test_core.py
│   ├── test_http_gateway.py   # Integration tests (module-scoped gateway)
│   ├── test_upstream.py
│   ├── test_load.py
│   ├── test_prometheus_metrics.py
│   └── upstream_server.py     # In-process upstream fixture
├── Cargo.toml
├── pyproject.toml
├── LICENSE
└── README.md

Contributing

Issues and pull requests are welcome via the GitHub repository.

Before submitting:

cargo check
cargo clippy -- -D warnings
maturin develop --release
python -m pytest -q

Please open an issue before starting large changes.

License

MIT — Copyright © 2024 Semko Kermashani

The name Kurd honors Kurdish identity and heritage. Bezhi Kurd u Kurdistan.

Project links

Data verified by PyPI on Aug 27, 2026
Data provided by the project maintainers, verified at the time the release was uploaded to PyPI.

Key dates

PyPI data
Data sourced directly from PyPI's database.
  • Released:
Newer release available (0.7.0)

1 maintainer

PyPI data
Data sourced directly from PyPI's database.
Avatar for semko from gravatar.com semko

Credits

Author: Semko Kermashani

GitHub Statistics

Data verified by PyPI on Aug 27, 2026
The GitHub source repository was provided by the project maintainers and verified by PyPI at the time of upload. Stars, forks, and open issues/PRs are derived from that repository and have not been independently verified.

License

MIT License (MIT)

Requires

Python >=3.10

Tags

mcp model-context-protocol gateway rust python ai

Classifiers

Report project as malware

Download files

Download the file for your platform. If you're not sure which to choose, learn more about installing packages.

Source Distribution

kurd-0.6.0.tar.gz (120.2 kB view details)

Uploaded Source

Built Distributions

If you're not sure about the file name format, learn more about wheel file names.

kurd-0.6.0-cp313-cp313-win_amd64.whl (2.5 MB view details)

Uploaded CPython 3.13Windows x86-64

kurd-0.6.0-cp313-cp313-manylinux_2_28_x86_64.whl (3.0 MB view details)

Uploaded CPython 3.13manylinux: glibc 2.28+ x86-64

kurd-0.6.0-cp313-cp313-macosx_11_0_arm64.whl (2.6 MB view details)

Uploaded CPython 3.13macOS 11.0+ ARM64

kurd-0.6.0-cp312-cp312-win_amd64.whl (2.5 MB view details)

Uploaded CPython 3.12Windows x86-64

kurd-0.6.0-cp312-cp312-manylinux_2_28_x86_64.whl (3.0 MB view details)

Uploaded CPython 3.12manylinux: glibc 2.28+ x86-64

kurd-0.6.0-cp312-cp312-macosx_11_0_arm64.whl (2.6 MB view details)

Uploaded CPython 3.12macOS 11.0+ ARM64

kurd-0.6.0-cp311-cp311-win_amd64.whl (2.5 MB view details)

Uploaded CPython 3.11Windows x86-64

kurd-0.6.0-cp311-cp311-manylinux_2_28_x86_64.whl (3.0 MB view details)

Uploaded CPython 3.11manylinux: glibc 2.28+ x86-64

kurd-0.6.0-cp311-cp311-macosx_11_0_arm64.whl (2.7 MB view details)

Uploaded CPython 3.11macOS 11.0+ ARM64

kurd-0.6.0-cp310-cp310-win_amd64.whl (2.5 MB view details)

Uploaded CPython 3.10Windows x86-64

kurd-0.6.0-cp310-cp310-manylinux_2_28_x86_64.whl (3.0 MB view details)

Uploaded CPython 3.10manylinux: glibc 2.28+ x86-64

kurd-0.6.0-cp310-cp310-macosx_11_0_arm64.whl (2.7 MB view details)

Uploaded CPython 3.10macOS 11.0+ ARM64

File details

Details for the file kurd-0.6.0.tar.gz.

File metadata

  • Download URL: kurd-0.6.0.tar.gz
  • Upload date:
  • Size: 120.2 kB
  • Tags: Source
  • Uploaded using Trusted Publishing? Yes
  • Uploaded via: twine/7.0.0 CPython/3.13.14

File hashes

Hashes for kurd-0.6.0.tar.gz
Algorithm Hash digest
SHA256 31d1f01989324076f7d3d119f71098fac7fb2b4e34271f4bc2eb3215297c9653
MD5 6d88261c1ba241bb3bc5d2499c31ce08
BLAKE2b-256 5e34ac86631ea67e2374965cb6b6585024262eae2b0634bcb9aa908d569bd3f9

See more details on using hashes here.

Provenance

The following attestation bundles were made for kurd-0.6.0.tar.gz:

Publisher: release.yml on sn391/kurd

Attestations: Values shown here reflect the state when the release was signed and may no longer be current.

File details

Details for the file kurd-0.6.0-cp313-cp313-win_amd64.whl.

File metadata

  • Download URL: kurd-0.6.0-cp313-cp313-win_amd64.whl
  • Upload date:
  • Size: 2.5 MB
  • Tags: CPython 3.13, Windows x86-64
  • Uploaded using Trusted Publishing? Yes
  • Uploaded via: twine/7.0.0 CPython/3.13.14

File hashes

Hashes for kurd-0.6.0-cp313-cp313-win_amd64.whl
Algorithm Hash digest
SHA256 6da46a49c0eb75da17b938389f4b0c4db5c72951f84b9d4001a8de4795c04ff6
MD5 7c0ed048a84960fe22d21c55ff0e225f
BLAKE2b-256 14bd5ceb5cd3c0815c4c802b3aa835f60f7d28ca6bf1d8a2424d055afebfad6c

See more details on using hashes here.

Provenance

The following attestation bundles were made for kurd-0.6.0-cp313-cp313-win_amd64.whl:

Publisher: release.yml on sn391/kurd

Attestations: Values shown here reflect the state when the release was signed and may no longer be current.

File details

Details for the file kurd-0.6.0-cp313-cp313-manylinux_2_28_x86_64.whl.

File metadata

File hashes

Hashes for kurd-0.6.0-cp313-cp313-manylinux_2_28_x86_64.whl
Algorithm Hash digest
SHA256 4257e1674c27c149d54145937fcf37df96f7c259c989bcb003cdcc4131e75a87
MD5 83ae83ff562f673aa9fb61409d870a25
BLAKE2b-256 545b6140abbfd224e179c5cbed17317d33e73a14726c9d3c7a32316f9897e847

See more details on using hashes here.

Provenance

The following attestation bundles were made for kurd-0.6.0-cp313-cp313-manylinux_2_28_x86_64.whl:

Publisher: release.yml on sn391/kurd

Attestations: Values shown here reflect the state when the release was signed and may no longer be current.

File details

Details for the file kurd-0.6.0-cp313-cp313-macosx_11_0_arm64.whl.

File metadata

File hashes

Hashes for kurd-0.6.0-cp313-cp313-macosx_11_0_arm64.whl
Algorithm Hash digest
SHA256 da0ee6ef302335dbe55002bc9961ba012f1def04c3672971fc9fc522b77c9813
MD5 1b9ae6542c80615170e2cec9bfe8e8e9
BLAKE2b-256 a2936eb8db2ee0a85c8f8c69dca988869ef2b3919d32d28f362aaded29782203

See more details on using hashes here.

Provenance

The following attestation bundles were made for kurd-0.6.0-cp313-cp313-macosx_11_0_arm64.whl:

Publisher: release.yml on sn391/kurd

Attestations: Values shown here reflect the state when the release was signed and may no longer be current.

File details

Details for the file kurd-0.6.0-cp312-cp312-win_amd64.whl.

File metadata

  • Download URL: kurd-0.6.0-cp312-cp312-win_amd64.whl
  • Upload date:
  • Size: 2.5 MB
  • Tags: CPython 3.12, Windows x86-64
  • Uploaded using Trusted Publishing? Yes
  • Uploaded via: twine/7.0.0 CPython/3.13.14

File hashes

Hashes for kurd-0.6.0-cp312-cp312-win_amd64.whl
Algorithm Hash digest
SHA256 5ab50aeaddc3f2806cb7f4f53c96e6bca504b2635e622c0c50d28a9b93388358
MD5 294246f2b964b533f43b92ad06491a30
BLAKE2b-256 5f7be134218cfc7fba74ab3f777d76f5df05ce08940a485a620166ebf208acd9

See more details on using hashes here.

Provenance

The following attestation bundles were made for kurd-0.6.0-cp312-cp312-win_amd64.whl:

Publisher: release.yml on sn391/kurd

Attestations: Values shown here reflect the state when the release was signed and may no longer be current.

File details

Details for the file kurd-0.6.0-cp312-cp312-manylinux_2_28_x86_64.whl.

File metadata

File hashes

Hashes for kurd-0.6.0-cp312-cp312-manylinux_2_28_x86_64.whl
Algorithm Hash digest
SHA256 29e8ca011d550dd06f88b685d19984e2d812d24204fdd6fb21dcf21a2f205fb0
MD5 6d59911c681938fdb468a5c56658b7ff
BLAKE2b-256 dea73b9fa98ec7a3603681524b3bea4c98e8dc1e95f3e6678ed41fae1adfd314

See more details on using hashes here.

Provenance

The following attestation bundles were made for kurd-0.6.0-cp312-cp312-manylinux_2_28_x86_64.whl:

Publisher: release.yml on sn391/kurd

Attestations: Values shown here reflect the state when the release was signed and may no longer be current.

File details

Details for the file kurd-0.6.0-cp312-cp312-macosx_11_0_arm64.whl.

File metadata

File hashes

Hashes for kurd-0.6.0-cp312-cp312-macosx_11_0_arm64.whl
Algorithm Hash digest
SHA256 e12da70657db84737c23711731731c29b8125412b224ebb6a8c65e0c955365ea
MD5 6ad01a8e1b13990e542c5085c277c4bb
BLAKE2b-256 d27ac940cf8b41f383e9b789062b2d7fa99746554aa6ba44cc3a085c742b7165

See more details on using hashes here.

Provenance

The following attestation bundles were made for kurd-0.6.0-cp312-cp312-macosx_11_0_arm64.whl:

Publisher: release.yml on sn391/kurd

Attestations: Values shown here reflect the state when the release was signed and may no longer be current.

File details

Details for the file kurd-0.6.0-cp311-cp311-win_amd64.whl.

File metadata

  • Download URL: kurd-0.6.0-cp311-cp311-win_amd64.whl
  • Upload date:
  • Size: 2.5 MB
  • Tags: CPython 3.11, Windows x86-64
  • Uploaded using Trusted Publishing? Yes
  • Uploaded via: twine/7.0.0 CPython/3.13.14

File hashes

Hashes for kurd-0.6.0-cp311-cp311-win_amd64.whl
Algorithm Hash digest
SHA256 dc6bead6de1726f4dc181aeb9f3c05f299df250ab0ec42833d7041d2e4944eb6
MD5 a97d73821ccbe0d6626eb152a14ef84d
BLAKE2b-256 159356b7872979eebed46c84e0d0e44aa65be18b00bac6470dd0d65a60c1509d

See more details on using hashes here.

Provenance

The following attestation bundles were made for kurd-0.6.0-cp311-cp311-win_amd64.whl:

Publisher: release.yml on sn391/kurd

Attestations: Values shown here reflect the state when the release was signed and may no longer be current.

File details

Details for the file kurd-0.6.0-cp311-cp311-manylinux_2_28_x86_64.whl.

File metadata

File hashes

Hashes for kurd-0.6.0-cp311-cp311-manylinux_2_28_x86_64.whl
Algorithm Hash digest
SHA256 b485ab5e8b332f313e16131017ebd69677baeb4cbec951adb69e4181e2813db2
MD5 95295e0042a99af65cf18f7a315c3e0a
BLAKE2b-256 4a3bdec9eb3f22fd2659109cb39e5acd3b2da06e2c7c80935392a6d61125e08e

See more details on using hashes here.

Provenance

The following attestation bundles were made for kurd-0.6.0-cp311-cp311-manylinux_2_28_x86_64.whl:

Publisher: release.yml on sn391/kurd

Attestations: Values shown here reflect the state when the release was signed and may no longer be current.

File details

Details for the file kurd-0.6.0-cp311-cp311-macosx_11_0_arm64.whl.

File metadata

File hashes

Hashes for kurd-0.6.0-cp311-cp311-macosx_11_0_arm64.whl
Algorithm Hash digest
SHA256 8dc61c00fa7c89c4794a7b5c822666a09da89b6e15bcc5218f1ff9ac7969a7af
MD5 98d3f5ed6645ccffe71e7d33391e4444
BLAKE2b-256 6c1c3ba0ae1210d31dfdcb224b5368c1ec773519a80ccfc201031cb84388ccdf

See more details on using hashes here.

Provenance

The following attestation bundles were made for kurd-0.6.0-cp311-cp311-macosx_11_0_arm64.whl:

Publisher: release.yml on sn391/kurd

Attestations: Values shown here reflect the state when the release was signed and may no longer be current.

File details

Details for the file kurd-0.6.0-cp310-cp310-win_amd64.whl.

File metadata

  • Download URL: kurd-0.6.0-cp310-cp310-win_amd64.whl
  • Upload date:
  • Size: 2.5 MB
  • Tags: CPython 3.10, Windows x86-64
  • Uploaded using Trusted Publishing? Yes
  • Uploaded via: twine/7.0.0 CPython/3.13.14

File hashes

Hashes for kurd-0.6.0-cp310-cp310-win_amd64.whl
Algorithm Hash digest
SHA256 3e0ea008f676d3e0678f67fe8139d9f04844fddb0647c5c8b174d7bd1f0e35dc
MD5 f26b0e70d79585aa306eb4768b529ebb
BLAKE2b-256 040b9a294f01fe2344287690c60ebc12a4f91ece6107c76d6cc69e00f9163326

See more details on using hashes here.

Provenance

The following attestation bundles were made for kurd-0.6.0-cp310-cp310-win_amd64.whl:

Publisher: release.yml on sn391/kurd

Attestations: Values shown here reflect the state when the release was signed and may no longer be current.

File details

Details for the file kurd-0.6.0-cp310-cp310-manylinux_2_28_x86_64.whl.

File metadata

File hashes

Hashes for kurd-0.6.0-cp310-cp310-manylinux_2_28_x86_64.whl
Algorithm Hash digest
SHA256 4d8da703414c42256550d3c2e6de0ba8e09376bee251eb7836648f752b5b7a01
MD5 069df9c047aba610513fcc209926eb28
BLAKE2b-256 e9e811d4d02ed749c491d1075f82e840ff35576307ec7c8cf97c2ddf8e2faf18

See more details on using hashes here.

Provenance

The following attestation bundles were made for kurd-0.6.0-cp310-cp310-manylinux_2_28_x86_64.whl:

Publisher: release.yml on sn391/kurd

Attestations: Values shown here reflect the state when the release was signed and may no longer be current.

File details

Details for the file kurd-0.6.0-cp310-cp310-macosx_11_0_arm64.whl.

File metadata

File hashes

Hashes for kurd-0.6.0-cp310-cp310-macosx_11_0_arm64.whl
Algorithm Hash digest
SHA256 059675bb4e5f68b7badd3d211fa90591ac9ccfc29b2866311e8ab046b8fac875
MD5 8fe4cdf7a6a9c86c7fcd1e8336266bf2
BLAKE2b-256 6995c619b9f20c95815d7a5793166d02f1cdd0e644b136a262d08efcf84fef94

See more details on using hashes here.

Provenance

The following attestation bundles were made for kurd-0.6.0-cp310-cp310-macosx_11_0_arm64.whl:

Publisher: release.yml on sn391/kurd

Attestations: Values shown here reflect the state when the release was signed and may no longer be current.

Release history Release notifications | RSS feed

0.7.0

13 files

This release

0.6.0 This release

13 files

0.5.0

13 files

0.4.0

4 files

0.3.0

4 files

0.2.0

4 files

Anthropic, PBC Visionary sponsor Bloomberg Visionary sponsor Hudson River Trading Visionary sponsor Meta Visionary sponsor NVIDIA Visionary sponsor Microsoft Sustainability sponsor Depot Continuous Integration AWS Cloud computing and Security Sponsor Datadog Monitoring Fastly CDN Google Download Analytics Sentry Error logging StatusPage Status page