omkit 0.0.2__py3-none-any.whl

omkit/tenant.py

@@ -0,0 +1,271 @@
+"""packages/omur-sdk/omkit/tenant.py — Per-request tenant isolation via contextvars.
+
+Middleware sets the tenant on each request. Handlers call require() to access.
+Background tasks use bind() to establish context.
+
+exports: require() | current_or_none() | request_id() | _DEFAULT_EXCLUDE | class TenantMiddleware | middleware(exclude_paths) | set_rls(session) | set_rls_conn(conn) | bind(tenant_id, request_id) | async_bind(tenant_id, request_id) | hashed_for_log(tenant_id, key)
+rules:   The tenant middleware must be applied before any database operations to ensure RLS policies are properly set, and all tenant context must be bound to the current request scope to maintain isolation between concurrent requests.
+agent:   ollama/qwen3-coder:latest | ollama | 2026-05-01 | codedna-cli | initial CodeDNA annotation pass
+message: 
+"""
+
+from __future__ import annotations
+
+import hashlib
+import hmac
+import json
+import os
+import uuid
+from contextvars import ContextVar
+from contextlib import asynccontextmanager, contextmanager
+from typing import TYPE_CHECKING, AsyncIterator, Callable
+
+import structlog
+
+if TYPE_CHECKING:
+    import asyncpg
+
+log = structlog.get_logger()
+
+_tenant_id_var: ContextVar[str | None] = ContextVar("tenant_id", default=None)
+_request_id_var: ContextVar[str | None] = ContextVar("request_id", default=None)
+
+
+def require() -> str:
+    """Return current tenant ID or raise RuntimeError.
+
+    Rules:   Tenant context must be set before calling this function, otherwise a RuntimeError is raised. Used in FastAPI middleware or background tasks via bind().
+    """
+    tid = _tenant_id_var.get()
+    if tid is None:
+        raise RuntimeError(
+            "No tenant context set. Use tenant.middleware() in FastAPI "
+            "or tenant.bind() for background tasks."
+        )
+    return tid
+
+
+def current_or_none() -> str | None:
+    """Return current tenant ID or None. For shared services where tenant is optional.
+
+    Rules:   Returns None if no tenant context is set; intended for optional tenant scenarios like shared services.
+    """
+    return _tenant_id_var.get()
+
+
+def request_id() -> str | None:
+    """Return current request ID or None.
+
+    Rules:   Returns None if no request ID is set; used for tracking requests across services.
+    """
+    return _request_id_var.get()
+
+
+_DEFAULT_EXCLUDE = frozenset({"/health", "/healthz", "/ready", "/readyz", "/metrics"})
+
+
+def _get_header(headers: list[tuple[bytes, bytes]], name: bytes) -> str | None:
+    """Extract a header value from raw ASGI headers."""
+    for key, value in headers:
+        if key.lower() == name:
+            return value.decode("latin-1")
+    return None
+
+
+def _validate_uuid(value: str) -> bool:
+    """Check if value is a valid UUID (any version, case-insensitive)."""
+    try:
+        uuid.UUID(value)
+        return True
+    except ValueError:
+        return False
+
+
+class TenantMiddleware:
+    """Pure ASGI middleware for tenant extraction.
+
+    Usage with FastAPI:
+        app.add_middleware(TenantMiddleware)
+        app.add_middleware(TenantMiddleware, exclude_paths={"/health", "/custom"})
+    """
+
+    def __init__(self, app, exclude_paths: set[str] | None = None) -> None:
+        self.app = app
+        self.excluded = frozenset(exclude_paths) if exclude_paths is not None else _DEFAULT_EXCLUDE
+
+    async def __call__(self, scope, receive, send):
+        if scope["type"] != "http":
+            await self.app(scope, receive, send)
+            return
+
+        path = scope.get("path", "")
+        if path in self.excluded:
+            await self.app(scope, receive, send)
+            return
+
+        headers = scope.get("headers", [])
+        raw_tid = _get_header(headers, b"x-tenant-id")
+
+        if not raw_tid or not _validate_uuid(raw_tid):
+            body = json.dumps({"error": "X-Tenant-ID header required"}).encode()
+            await send({
+                "type": "http.response.start",
+                "status": 401,
+                "headers": [
+                    (b"content-type", b"application/json"),
+                    (b"content-length", str(len(body)).encode()),
+                ],
+            })
+            await send({"type": "http.response.body", "body": body})
+            return
+
+        raw_rid = _get_header(headers, b"x-request-id") or str(uuid.uuid4())
+
+        tid_token = _tenant_id_var.set(raw_tid)
+        rid_token = _request_id_var.set(raw_rid)
+
+        async def send_with_request_id(message):
+            if message.get("type") == "http.response.start":
+                resp_headers = list(message.get("headers", []))
+                resp_headers.append((b"x-request-id", raw_rid.encode()))
+                message = {**message, "headers": resp_headers}
+            await send(message)
+
+        try:
+            await self.app(scope, receive, send_with_request_id)
+        finally:
+            _tenant_id_var.reset(tid_token)
+            _request_id_var.reset(rid_token)
+
+
+def middleware(exclude_paths: set[str] | None = None) -> Callable:
+    """ASGI middleware factory. Prefer TenantMiddleware class with app.add_middleware().
+
+    This factory form works for raw ASGI wrapping (tests).
+    For FastAPI, use: app.add_middleware(TenantMiddleware)
+
+    Rules:   This function returns a factory for ASGI middleware; prefer using TenantMiddleware class directly with app.add_middleware() for FastAPI apps.
+    """
+    excluded = exclude_paths
+
+    def asgi_middleware(app):
+        mw = TenantMiddleware(app, exclude_paths=excluded)
+        return mw
+
+    return asgi_middleware
+
+
+async def set_rls(session) -> None:
+    """Set PostgreSQL RLS tenant context. Must be called inside an active transaction.
+
+    Uses transaction-local set_config so the setting resets when the transaction ends.
+    Requires sqlalchemy (optional dependency).
+
+    Rules:   Must be called inside an active SQLAlchemy transaction; otherwise raises RuntimeError. Sets PostgreSQL RLS context using set_config within the transaction.
+    """
+    from sqlalchemy import text
+
+    if not session.in_transaction():
+        raise RuntimeError(
+            "set_rls() must be called inside an active transaction. "
+            "Use 'async with session.begin():' before calling."
+        )
+    tid = require()
+    await session.execute(
+        text("SELECT set_config('app.tenant_id', :tid, true)"),
+        {"tid": tid},
+    )
+
+
+async def set_rls_conn(conn: "asyncpg.Connection") -> None:
+    """Set PostgreSQL RLS tenant context on an asyncpg connection.
+
+    Asyncpg counterpart of set_rls(). Reads tenant from ContextVar (require()).
+    Must be called inside an active transaction — set_config(..., true) is
+    transaction-local; outside a transaction the setting silently leaks across
+    pooled checkouts (cross-tenant data leak risk).
+
+    Rules:   Must be called inside an active asyncpg transaction; otherwise raises RuntimeError. Sets PostgreSQL RLS context using set_config within the transaction to prevent cross-tenant data leaks.
+    """
+    if not conn.is_in_transaction():
+        raise RuntimeError(
+            "set_rls_conn() must be called inside an active transaction. "
+            "Use 'async with conn.transaction():' before calling."
+        )
+    tid = require()
+    await conn.execute("SELECT set_config('app.tenant_id', $1, true)", tid)
+
+
+@contextmanager
+def bind(tenant_id: str, request_id: str | None = None):
+    """Set tenant context for background tasks, scripts, and tests.
+
+    Resets on exit, even if an exception is raised.
+
+    Rules:   Sets tenant and request ID in ContextVars for background tasks, scripts, or tests; resets values on exit even if an exception occurs.
+    """
+    tid_token = _tenant_id_var.set(tenant_id)
+    rid_token = _request_id_var.set(request_id)
+    try:
+        yield
+    finally:
+        _tenant_id_var.reset(tid_token)
+        _request_id_var.reset(rid_token)
+
+
+@asynccontextmanager
+async def async_bind(
+    tenant_id: str, request_id: str | None = None
+) -> AsyncIterator[None]:
+    """Async counterpart of bind() for use inside `async with` blocks.
+
+    ContextVar set/reset itself is sync; this is a convenience wrapper so
+    job-queue middleware and other async code can write `async with
+    tenant.async_bind(tid):` without a `with` inside `async def`.
+
+    Rules:   Async version of bind(); used in async contexts with `async with tenant.async_bind(tid):` to manage tenant context.
+    """
+    tid_token = _tenant_id_var.set(tenant_id)
+    rid_token = _request_id_var.set(request_id)
+    try:
+        yield
+    finally:
+        _tenant_id_var.reset(tid_token)
+        _request_id_var.reset(rid_token)
+
+
+def hashed_for_log(tenant_id: str, key: bytes | None = None) -> str:
+    """HMAC-SHA-256 of tenant_id for log/metric correlation without re-id risk.
+
+    Plain SHA-256 over a finite tenant population is brute-forceable; HMAC with
+    a per-deployment secret is not. Reads LOG_HMAC_KEY from env when key
+    not supplied. Returns first 16 hex chars (8 bytes) — enough entropy for
+    correlation, short enough for log lines.
+
+    Key encoding contract: LOG_HMAC_KEY must be a hex string (output of
+    `openssl rand -hex 32`). hashed_for_log decodes it to raw bytes before
+    HMAC, so the full 256 bits of entropy are used. A bare ASCII passphrase
+    will silently work but only at ~5 bits/char effective key strength.
+
+    Rules:   Requires LOG_HMAC_KEY environment variable to be set as a hex-encoded 32-byte key; returns first 16 hex chars of HMAC-SHA-256 for log correlation.
+    """
+    if key is None:
+        env = os.environ.get("LOG_HMAC_KEY")
+        if not env:
+            raise RuntimeError(
+                "LOG_HMAC_KEY env var required for tenant log hashing. "
+                "Set in BaseServiceSettings or pass key= explicitly."
+            )
+        try:
+            key = bytes.fromhex(env)
+        except ValueError as exc:
+            raise RuntimeError(
+                "LOG_HMAC_KEY must be a hex string (openssl rand -hex 32). "
+                f"Got {len(env)} chars, decode error: {exc}"
+            ) from exc
+        if len(key) < 16:
+            raise RuntimeError(
+                f"LOG_HMAC_KEY too short ({len(key)} bytes); need >= 16"
+            )
+    digest = hmac.new(key, tenant_id.encode("utf-8"), hashlib.sha256).hexdigest()
+    return digest[:16]

omkit/tracing.py

@@ -0,0 +1,80 @@
+"""packages/omur-sdk/omkit/tracing.py — OpenTelemetry tracing bootstrap for Omur services.
+
+Usage:
+    from omkit.tracing import init_tracing
+    init_tracing("spine")  # Call once at startup
+
+Tracing is OFF by default since the 2026-04 infra consolidation (Alloy and
+Tempo were removed). Set OTEL_EXPORTER_OTLP_ENDPOINT to a reachable OTLP/HTTP
+collector (e.g. ``http://otel-collector:4318``) to re-enable span export.
+
+exports: DEFAULT_ENDPOINT | init_tracing(service_name, endpoint) | instrument_fastapi(app)
+rules:   The tracing module must maintain backward compatibility with all existing FastAPI instrumentation patterns and cannot introduce breaking changes to the existing service_name and endpoint parameter signatures. The module requires explicit error handling for endpoint connection failures and must not modify global tracing state outside of the init_tracing and instrument_fastapi functions. All tracing operations must be thread-safe and support concurrent FastAPI application instances.
+agent:   ollama/qwen3-coder:latest | ollama | 2026-05-01 | codedna-cli | initial CodeDNA annotation pass
+message: 
+"""
+
+from __future__ import annotations
+
+import os
+import structlog
+
+log = structlog.get_logger()
+
+DEFAULT_ENDPOINT = ""
+
+
+def init_tracing(
+    service_name: str,
+    endpoint: str | None = None,
+) -> "TracerProvider | None":
+    """Initialize OpenTelemetry with OTLP/HTTP export.
+
+    Returns the TracerProvider, or None if tracing is disabled.
+
+    Rules:   Must ensure OTEL_EXPORTER_OTLP_ENDPOINT environment variable is set when endpoint is None and DEFAULT_ENDPOINT is not provided, otherwise tracing will be silently disabled.
+    """
+    if endpoint is None:
+        endpoint = os.environ.get("OTEL_EXPORTER_OTLP_ENDPOINT", DEFAULT_ENDPOINT)
+
+    if not endpoint:
+        log.info("tracing.disabled", service=service_name)
+        return None
+
+    try:
+        from opentelemetry import trace
+        from opentelemetry.sdk.trace import TracerProvider
+        from opentelemetry.sdk.trace.export import BatchSpanProcessor
+        from opentelemetry.sdk.resources import Resource
+        from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter
+    except ImportError:
+        log.info("tracing.not_installed", service=service_name)
+        return None
+
+    resource = Resource.create({"service.name": service_name})
+    provider = TracerProvider(resource=resource)
+    exporter = OTLPSpanExporter(endpoint=f"{endpoint}/v1/traces")
+    provider.add_span_processor(BatchSpanProcessor(exporter))
+    trace.set_tracer_provider(provider)
+
+    log.info("tracing.enabled", service=service_name, endpoint=endpoint)
+    return provider
+
+
+def instrument_fastapi(app) -> None:
+    """Wrap a FastAPI app with OpenTelemetry server-side instrumentation.
+
+    Idempotent: calling twice on the same app is a no-op. Silently no-ops if
+    opentelemetry-instrumentation-fastapi is not installed (in-tree optional).
+
+    Rules:   Function is idempotent but requires opentelemetry-instrumentation-fastapi package to be installed, otherwise it will silently no-op without raising an error.
+    """
+    try:
+        from opentelemetry.instrumentation.fastapi import FastAPIInstrumentor
+    except ImportError:
+        return
+
+    if getattr(app, "_omur_otel_instrumented", False):
+        return
+    FastAPIInstrumentor.instrument_app(app)
+    app._omur_otel_instrumented = True

omkit/transport/__init__.py

@@ -0,0 +1,29 @@
+"""packages/omur-sdk/omkit/transport/__init__.py — re-exports cross-cutting wire / observability primitives.
+
+This is an additive grouping for discoverability. Existing imports from the
+flat modules (``omkit.http``, ``omkit.tracing``, etc.) continue to work
+unchanged; new code is encouraged to import from this facade.
+
+exports: none
+rules:   The transport module must maintain backward compatibility for all existing API endpoints and response formats, as breaking changes will affect downstream services that depend on stable interfaces. All network communication must go through a centralized connection pooling mechanism to ensure resource efficiency and proper handling of concurrent requests. The module cannot introduce any synchronous blocking operations that would impact the overall performance of applications using the SDK.
+agent:   ollama/qwen3-coder:latest | ollama | 2026-05-01 | codedna-cli | initial CodeDNA annotation pass
+message: 
+"""
+
+from omkit.health import mount_health_endpoints
+from omkit.http import build_tenant_client
+from omkit.logging import configure_logging
+from omkit.metrics import mount_metrics
+from omkit.resilience import CircuitBreaker, resilient
+from omkit.tracing import init_tracing, instrument_fastapi
+
+__all__ = [
+    "build_tenant_client",
+    "init_tracing",
+    "instrument_fastapi",
+    "mount_metrics",
+    "mount_health_endpoints",
+    "configure_logging",
+    "CircuitBreaker",
+    "resilient",
+]

omkit/valkey.py

@@ -0,0 +1,45 @@
+"""packages/omur-sdk/omkit/valkey.py — Valkey client factory.
+
+Single source of truth for `redis.asyncio.Redis` construction across the SDK.
+Replaces the URL-construction duplication in `eventbus.new_bus()` and other
+call sites. Reads BaseServiceSettings.valkey_url so password handling stays
+consistent.
+
+Note: streaq does not use this factory — streaq depends on `coredis`, a
+different async Redis client. Services that use streaq construct the Worker
+directly from `settings.valkey_url`.
+
+exports: new_client(settings)
+rules:   The module must maintain backward compatibility with existing Redis connection patterns while ensuring all async operations are properly awaited. The client initialization must respect the settings structure defined in the SDK's configuration schema. All Redis operations must be wrapped with appropriate timeout and retry logic to prevent service disruptions.
+agent:   ollama/qwen3-coder:latest | ollama | 2026-05-01 | codedna-cli | initial CodeDNA annotation pass
+message: 
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    import redis.asyncio as aioredis
+
+    from omkit.config import BaseServiceSettings
+
+
+def new_client(
+    settings: "BaseServiceSettings", **kwargs: Any
+) -> "aioredis.Redis":
+    """Build a redis.asyncio.Redis client from BaseServiceSettings.
+
+    Reuses settings.valkey_url to keep password handling and host/port logic
+    in one place. Empty password falls back to no-auth URL — fail-fast on
+    empty password is enforced at compose-startup via the
+    `${VALKEY_PASSWORD:?VALKEY_PASSWORD required}` interpolation, not here.
+
+    Extra kwargs pass through to redis.asyncio.from_url (decode_responses,
+    socket_timeout, etc.).
+
+    Rules:   The function relies on settings.valkey_url being properly configured with a valid Redis connection string. It assumes that password handling and host/port logic are correctly implemented in the BaseServiceSettings, and that the VALKEY_PASSWORD environment variable is enforced at startup to prevent empty passwords.
+    """
+    import redis.asyncio as aioredis
+
+    return aioredis.from_url(settings.valkey_url, **kwargs)

omkit-0.0.2.dist-info/METADATA

@@ -0,0 +1,29 @@
+Metadata-Version: 2.4
+Name: omkit
+Version: 0.0.2
+Summary: Multi-tenant SaaS scaffolding for Python services.
+Requires-Python: >=3.12
+Requires-Dist: pydantic>=2.13
+Requires-Dist: pydantic-settings>=2.13
+Requires-Dist: asyncpg>=0.31
+Requires-Dist: redis>=7.4
+Requires-Dist: structlog>=25.5
+Requires-Dist: cryptography>=47.0
+Requires-Dist: tenacity>=9.1
+Requires-Dist: prometheus_client>=0.25
+Requires-Dist: httpx>=0.28.1
+Requires-Dist: sqlalchemy[asyncio]>=2.0.49
+Provides-Extra: dev
+Requires-Dist: fastapi>=0.136.0; extra == "dev"
+Requires-Dist: pytest>=9.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=1.3; extra == "dev"
+Requires-Dist: redis>=7.4; extra == "dev"
+Requires-Dist: respx>=0.21; extra == "dev"
+Provides-Extra: tracing
+Requires-Dist: opentelemetry-api>=1.41.0; extra == "tracing"
+Requires-Dist: opentelemetry-sdk>=1.41.0; extra == "tracing"
+Requires-Dist: opentelemetry-exporter-otlp-proto-http>=1.41.0; extra == "tracing"
+Requires-Dist: opentelemetry-instrumentation-fastapi>=0.62b0; extra == "tracing"
+Requires-Dist: opentelemetry-instrumentation-httpx>=0.62b0; extra == "tracing"
+Provides-Extra: metrics
+Requires-Dist: prometheus-fastapi-instrumentator>=7.1; extra == "metrics"

omkit-0.0.2.dist-info/RECORD

@@ -0,0 +1,40 @@
+omkit/__init__.py,sha256=9wLFyshKmCV8EM4wtNs_Hp_yUlTec4Yq2BxrwnhUz10,518
+omkit/cleanup.py,sha256=7Pss_w6dZx9VRGrHPfLD8fILdVsOYzUJrs953rih8NE,2415
+omkit/config.py,sha256=TD554an8GC7WdKkuhDFbnErDvLZkEWjFXEFIq9ReCfo,1846
+omkit/cost.py,sha256=b4EoJekhj-UdqJDM3ETyuFT7Ea9ccko7osr-nX1-3F8,2752
+omkit/dbpool.py,sha256=vI3HNbolu1OmWnJbEz1eD_X2QZNFrZohHzsPVyHXVEo,6182
+omkit/encryption.py,sha256=kM_iOXk80zJn4NhIYFFmonho-uTdcXG14IaYeI6umms,2546
+omkit/eventbus.py,sha256=-A6ALK3dNk8xjkuNOOkL_i8SnN2WREhb3bzjwh7ZuNI,16296
+omkit/events.py,sha256=Qg9SEnsLX-KmvpRzOBDqEcJlBbx5l7c0X4aJV4PZvuo,1117
+omkit/health.py,sha256=PP7fa2JkWtKf6lLZsa6GjxndSL0UD7iVuA5wGhX5RyU,3236
+omkit/http.py,sha256=mEpxp2LZ25ZBEu0lVbsq_lqGIfIW8b3npQ7mKKzdYGM,3423
+omkit/logging.py,sha256=LtH8uCix9U1Y-osvY2YIgz9aakYgtZ-eRjSUPydwXpY,3290
+omkit/metrics.py,sha256=LftIRzSRDFDj1e1QGv5a8CEUkWSuI-vpYZAUqicMJss,1432
+omkit/model_lifecycle.py,sha256=VB20gfP4GeVDr0d77sKkDHkmU_jk7JKglTrHWaIiaMs,6163
+omkit/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+omkit/quota.py,sha256=R2rxRmn7yBiU-5DmUVvGL-j0rpNZCPvS22Nhx1tIZmA,6682
+omkit/resilience.py,sha256=P7IdHjRop80wIuWIHPKxO4629OgHsVGr1TmzRmQCxzo,5238
+omkit/sanitize.py,sha256=hE4RrRcRnqT4Wk5F1fTXUtbxpTo5Dh4UXdkYybRn81M,4646
+omkit/sessions.py,sha256=vv2lF6e8-reGNQr_Nba3C4Jg7veCixi1sPwi4XYArac,15489
+omkit/settings.py,sha256=wEBemRcALeaA2CAXikcQ1ktfLARgzXFzF4RK3HjC3Uk,14792
+omkit/sync_notifier.py,sha256=Zr-mVzJDClC82aQO80944b8oFrWJhY2RnkVEcuF0sX4,5228
+omkit/tenant.py,sha256=jpV-tXsmudFScQGmN3jj-VDWpiRbT1QOQHbzikH9C3o,10305
+omkit/tracing.py,sha256=J2atOwD13wdnMpx68AUCEDo81AP0MQBK-JjkOB4fo5w,3415
+omkit/valkey.py,sha256=KbRWbNEcjlYEhApfIz6LKjiodSxkql2Z7sTmDB1gL-Y,2183
+omkit/data/__init__.py,sha256=jAX729bco_Jv4m-l1mhnUvOGuUSbuOjrCeFGObYin50,1106
+omkit/internal/__init__.py,sha256=JCAYaVasGvY1GJ5SCXHV7Q1uQSEy1BYJICelXSPjIqM,258
+omkit/internal/crypto.py,sha256=ddPwA4JQgy8t116OxCXUFplsrorrADW3wanHMXdlBxg,904
+omkit/jobqueue/__init__.py,sha256=XHYU229TG73AVM8g1Dhn636MArvzPrdMp2PGTKTzGPQ,1174
+omkit/jobqueue/envelope.py,sha256=-8FVv2ZhaC9KtVzYkU8qOaRNiECx0h1KrjPnDi5M3s4,4608
+omkit/jobqueue/streaq.py,sha256=g_t8DK-1K1-SYuiTHHUjVktiaqAi9HCFLzfj8TLMTO0,11104
+omkit/platform/__init__.py,sha256=BN6cqsUyGWMgVRb_hQKiSDVyo51-BSOQ708cv4N5EBI,490
+omkit/providers/__init__.py,sha256=1JMezeFpDRzIF15f1LNBe-lIIWUf_Bfaqtjx2rSc-OM,419
+omkit/providers/base.py,sha256=YG01V18FYHQHxUNV9-DGTdtjeu-BuqjT0py5lhelATE,2787
+omkit/providers/registry.py,sha256=peM134Z9Zib-9krjyImlqLZGeBL8uzw0zFCd-cIQib4,11257
+omkit/security/__init__.py,sha256=pmE98gw2DO87fMMKcZjcOkg2_L8wV919Ig5afI_sKkA,1231
+omkit/security/events.py,sha256=ur0oRFuoaj-E5KhrxPoZd0mphkGNHsGWH9A4UGf-V5s,2687
+omkit/transport/__init__.py,sha256=YF5U0wCaJzEn2aMBhgMkky6AyT4JUyCycoRqNbMjD4U,1451
+omkit-0.0.2.dist-info/METADATA,sha256=vz3GMY3pUiFjUzkTaJ8ZjVqdNQt95toW7Y9XyrnJUVs,1195
+omkit-0.0.2.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+omkit-0.0.2.dist-info/top_level.txt,sha256=sCEPnxCXPMDdG0h3BXj0COELTJHdOn5q_LycbET5zrg,6
+omkit-0.0.2.dist-info/RECORD,,

omkit-0.0.2.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

omkit-0.0.2.dist-info/top_level.txt

@@ -0,0 +1 @@
+omkit