kimetsu 0.1.0__py3-none-any.whl

kimetsu/__init__.py

@@ -0,0 +1,26 @@
+from .async_client import AsyncKimetsuClient
+from .client import KimetsuClient
+from .errors import (
+    KimetsuError,
+    KimetsuAuthError,
+    KimetsuRateLimitError,
+    KimetsuToolError,
+    KimetsuProtocolError,
+)
+from .models import Context, Memory, Status
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "AsyncKimetsuClient",
+    "KimetsuClient",
+    "__version__",
+    "Context",
+    "Memory",
+    "Status",
+    "KimetsuError",
+    "KimetsuAuthError",
+    "KimetsuRateLimitError",
+    "KimetsuToolError",
+    "KimetsuProtocolError",
+]

kimetsu/_transport.py

@@ -0,0 +1,126 @@
+from __future__ import annotations
+
+import asyncio
+import itertools
+from typing import Any
+from typing import Dict
+from typing import Optional
+
+import httpx
+
+from .errors import KimetsuAuthError
+from .errors import KimetsuProtocolError
+from .errors import KimetsuRateLimitError
+from .errors import KimetsuToolError
+
+PROTOCOL_VERSION = "2024-11-05"
+
+
+def build_call(name: str, arguments: Dict[str, Any], *, request_id: int) -> Dict[str, Any]:
+    return {"jsonrpc": "2.0", "id": request_id, "method": "tools/call",
+            "params": {"name": name, "arguments": arguments}}
+
+
+def _build_initialize(request_id: int, protocol_version: str) -> Dict[str, Any]:
+    return {"jsonrpc": "2.0", "id": request_id, "method": "initialize",
+            "params": {"protocolVersion": protocol_version, "capabilities": {},
+                       "clientInfo": {"name": "kimetsu-py", "version": "0.1.0"}}}
+
+
+def parse_envelope(status_code: int, body: Dict[str, Any], headers: Dict[str, str]) -> Dict[str, Any]:
+    if status_code in (401, 403):
+        raise KimetsuAuthError(f"authentication failed (HTTP {status_code})")
+    if status_code == 429:
+        ra = headers.get("retry-after")
+        retry_after: Optional[float] = None
+        if ra:
+            try:
+                retry_after = float(ra)
+            except ValueError:
+                retry_after = None
+        raise KimetsuRateLimitError("rate limited (HTTP 429)", retry_after=retry_after)
+    if status_code >= 400:
+        raise KimetsuProtocolError(f"unexpected HTTP {status_code}")
+    if "error" in body:
+        err = body["error"]
+        raise KimetsuToolError(err.get("message", "tool error"), code=err.get("code"))
+    if "result" not in body:
+        raise KimetsuProtocolError("missing result in JSON-RPC envelope")
+    result: Dict[str, Any] = body["result"]
+    return result
+
+
+class SyncTransport:
+    def __init__(self, base_url: str, token: str, repo: str, *,
+                 timeout: float = 30.0, protocol_version: str = PROTOCOL_VERSION,
+                 client: Optional[httpx.Client] = None) -> None:
+        self._url = f"{base_url.rstrip('/')}/mcp/{repo}"
+        self._headers = {"authorization": f"Bearer {token}", "content-type": "application/json"}
+        self._protocol_version = protocol_version
+        self._ids = itertools.count(1)
+        self._client = client or httpx.Client(timeout=timeout)
+        self._initialized = False
+
+    def _post(self, payload: Dict[str, Any]) -> Dict[str, Any]:
+        resp = self._client.post(self._url, headers=self._headers, json=payload)
+        try:
+            body = resp.json() if resp.content else {}
+        except ValueError:
+            body = {}
+        return parse_envelope(resp.status_code, body, dict(resp.headers))
+
+    def _ensure_init(self) -> None:
+        if self._initialized:
+            return
+        result = self._post(_build_initialize(next(self._ids), self._protocol_version))
+        got = result.get("protocolVersion")
+        if got and got != self._protocol_version:
+            raise KimetsuProtocolError(f"server protocol {got} != {self._protocol_version}")
+        self._initialized = True
+
+    def call(self, name: str, arguments: Dict[str, Any]) -> Dict[str, Any]:
+        self._ensure_init()
+        return self._post(build_call(name, arguments, request_id=next(self._ids)))
+
+    def close(self) -> None:
+        self._client.close()
+
+
+class AsyncTransport:
+    def __init__(self, base_url: str, token: str, repo: str, *,
+                 timeout: float = 30.0, protocol_version: str = PROTOCOL_VERSION,
+                 client: Optional[httpx.AsyncClient] = None) -> None:
+        self._url = f"{base_url.rstrip('/')}/mcp/{repo}"
+        self._headers = {"authorization": f"Bearer {token}", "content-type": "application/json"}
+        self._protocol_version = protocol_version
+        self._ids = itertools.count(1)
+        self._client = client or httpx.AsyncClient(timeout=timeout)
+        self._initialized = False
+        self._init_lock = asyncio.Lock()
+
+    async def _post(self, payload: Dict[str, Any]) -> Dict[str, Any]:
+        resp = await self._client.post(self._url, headers=self._headers, json=payload)
+        try:
+            body = resp.json() if resp.content else {}
+        except ValueError:
+            body = {}
+        return parse_envelope(resp.status_code, body, dict(resp.headers))
+
+    async def _ensure_init(self) -> None:
+        if self._initialized:
+            return
+        async with self._init_lock:
+            if self._initialized:
+                return
+            result = await self._post(_build_initialize(next(self._ids), self._protocol_version))
+            got = result.get("protocolVersion")
+            if got and got != self._protocol_version:
+                raise KimetsuProtocolError(f"server protocol {got} != {self._protocol_version}")
+            self._initialized = True
+
+    async def call(self, name: str, arguments: Dict[str, Any]) -> Dict[str, Any]:
+        await self._ensure_init()
+        return await self._post(build_call(name, arguments, request_id=next(self._ids)))
+
+    async def aclose(self) -> None:
+        await self._client.aclose()

kimetsu/async_client.py

@@ -0,0 +1,132 @@
+from __future__ import annotations
+from typing import Any, Dict, List, Optional
+import os
+from ._transport import AsyncTransport
+from .client import _clean
+from .models import Context, Memory, Status
+
+
+class _AsyncMemory:
+    def __init__(self, t: Any) -> None:
+        self._t = t
+
+    async def search(self, query: str, **kw: Any) -> Dict[str, Any]:
+        res: Dict[str, Any] = await self._t.call("kimetsu_brain_memory_search", _clean({"query": query, **kw}))
+        return res
+
+    async def add(self, text: str, *, scope: str, kind: Optional[str] = None, **kw: Any) -> Memory:
+        return Memory.model_validate(await self._t.call("kimetsu_brain_memory_add", _clean({"text": text, "scope": scope, "kind": kind, **kw})))
+
+    async def list(self, **kw: Any) -> Dict[str, Any]:
+        res: Dict[str, Any] = await self._t.call("kimetsu_brain_memory_list", _clean(kw))
+        return res
+
+    async def top(self, **kw: Any) -> Dict[str, Any]:
+        res: Dict[str, Any] = await self._t.call("kimetsu_brain_memory_top", _clean(kw))
+        return res
+
+    async def accept(self, proposal_id: str, **kw: Any) -> Dict[str, Any]:
+        res: Dict[str, Any] = await self._t.call("kimetsu_brain_memory_accept", _clean({"proposal_id": proposal_id, **kw}))
+        return res
+
+    async def reject(self, proposal_id: str, **kw: Any) -> Dict[str, Any]:
+        res: Dict[str, Any] = await self._t.call("kimetsu_brain_memory_reject", _clean({"proposal_id": proposal_id, **kw}))
+        return res
+
+    async def invalidate(self, memory_id: str, **kw: Any) -> Dict[str, Any]:
+        res: Dict[str, Any] = await self._t.call("kimetsu_brain_memory_invalidate", _clean({"memory_id": memory_id, **kw}))
+        return res
+
+    async def blame(self, run_id: str, **kw: Any) -> Dict[str, Any]:
+        """Per-run citation attribution: which memories a run cited. Pass a run_id (ULID)."""
+        res: Dict[str, Any] = await self._t.call("kimetsu_brain_memory_blame", _clean({"run_id": run_id, **kw}))
+        return res
+
+    async def proposals(self, **kw: Any) -> Dict[str, Any]:
+        res: Dict[str, Any] = await self._t.call("kimetsu_brain_memory_proposals", _clean(kw))
+        return res
+
+    async def conflicts(self, **kw: Any) -> Dict[str, Any]:
+        res: Dict[str, Any] = await self._t.call("kimetsu_brain_memory_conflicts", _clean(kw))
+        return res
+
+    async def conflict_resolve(self, **kw: Any) -> Dict[str, Any]:
+        res: Dict[str, Any] = await self._t.call("kimetsu_brain_conflict_resolve", _clean(kw))
+        return res
+
+    async def prune(self, **kw: Any) -> Dict[str, Any]:
+        res: Dict[str, Any] = await self._t.call("kimetsu_brain_prune", _clean(kw))
+        return res
+
+
+class _AsyncConfig:
+    def __init__(self, t: Any) -> None:
+        self._t = t
+
+    async def show(self, **kw: Any) -> Dict[str, Any]:
+        res: Dict[str, Any] = await self._t.call("kimetsu_brain_config_show", _clean(kw))
+        return res
+
+
+class _AsyncModels:
+    def __init__(self, t: Any) -> None:
+        self._t = t
+
+    async def list(self, **kw: Any) -> Dict[str, Any]:
+        res: Dict[str, Any] = await self._t.call("kimetsu_brain_model_list", _clean(kw))
+        return res
+
+
+class _AsyncBenchmark:
+    def __init__(self, t: Any) -> None:
+        self._t = t
+
+    async def context(self, query: str, **kw: Any) -> Dict[str, Any]:
+        res: Dict[str, Any] = await self._t.call("kimetsu_benchmark_context", _clean({"query": query, **kw}))
+        return res
+
+    async def record_outcome(self, task: str, **kw: Any) -> Dict[str, Any]:
+        res: Dict[str, Any] = await self._t.call("kimetsu_benchmark_record_outcome", _clean({"task": task, **kw}))
+        return res
+
+
+class AsyncKimetsuClient:
+    def __init__(self, base_url: Optional[str] = None, token: Optional[str] = None,
+                 repo: Optional[str] = None, *, timeout: float = 30.0,
+                 transport: Optional[Any] = None) -> None:
+        if transport is not None:
+            self._t = transport
+        else:
+            base_url = base_url or os.environ["KIMETSU_REMOTE_URL"]
+            token = token or os.environ["KIMETSU_REMOTE_TOKEN"]
+            repo = repo or os.environ["KIMETSU_REMOTE_REPO"]
+            self._t = AsyncTransport(base_url, token, repo, timeout=timeout)
+        self.memory = _AsyncMemory(self._t)
+        self.config = _AsyncConfig(self._t)
+        self.models = _AsyncModels(self._t)
+        self.benchmark = _AsyncBenchmark(self._t)
+
+    async def context(self, query: str, *, tags: Optional[List[str]] = None, **kw: Any) -> Context:
+        return Context.model_validate(await self._t.call("kimetsu_brain_context", _clean({"query": query, "tags": tags, **kw})))
+
+    async def record(self, lesson: str, *, tags: List[str],
+                     kind: Optional[str] = None, **kw: Any) -> Dict[str, Any]:
+        res: Dict[str, Any] = await self._t.call("kimetsu_brain_record", _clean({"lesson": lesson, "tags": tags, "kind": kind, **kw}))
+        return res
+
+    async def status(self) -> Status:
+        return Status.model_validate(await self._t.call("kimetsu_brain_status", {}))
+
+    async def insights(self) -> Dict[str, Any]:
+        res: Dict[str, Any] = await self._t.call("kimetsu_brain_insights", {})
+        return res
+
+    async def aclose(self) -> None:
+        if hasattr(self._t, "aclose"):
+            await self._t.aclose()
+
+    async def __aenter__(self) -> "AsyncKimetsuClient":
+        return self
+
+    async def __aexit__(self, *exc: Any) -> None:
+        await self.aclose()

kimetsu/client.py

@@ -0,0 +1,141 @@
+from __future__ import annotations
+from typing import Any, Dict, List, Optional
+import os
+from ._transport import SyncTransport
+from .models import Context, Memory, Status
+
+
+def _clean(d: Dict[str, Any]) -> Dict[str, Any]:
+    return {k: v for k, v in d.items() if v is not None}
+
+
+class _Memory:
+    def __init__(self, t: Any) -> None:
+        self._t = t
+
+    def search(self, query: str, **kw: Any) -> Dict[str, Any]:
+        res: Dict[str, Any] = self._t.call("kimetsu_brain_memory_search", _clean({"query": query, **kw}))
+        return res
+
+    def add(self, text: str, *, scope: str, kind: Optional[str] = None, **kw: Any) -> Memory:
+        return Memory.model_validate(
+            self._t.call("kimetsu_brain_memory_add", _clean({"text": text, "scope": scope, "kind": kind, **kw}))
+        )
+
+    def list(self, **kw: Any) -> Dict[str, Any]:
+        res: Dict[str, Any] = self._t.call("kimetsu_brain_memory_list", _clean(kw))
+        return res
+
+    def top(self, **kw: Any) -> Dict[str, Any]:
+        res: Dict[str, Any] = self._t.call("kimetsu_brain_memory_top", _clean(kw))
+        return res
+
+    def accept(self, proposal_id: str, **kw: Any) -> Dict[str, Any]:
+        res: Dict[str, Any] = self._t.call("kimetsu_brain_memory_accept", _clean({"proposal_id": proposal_id, **kw}))
+        return res
+
+    def reject(self, proposal_id: str, **kw: Any) -> Dict[str, Any]:
+        res: Dict[str, Any] = self._t.call("kimetsu_brain_memory_reject", _clean({"proposal_id": proposal_id, **kw}))
+        return res
+
+    def invalidate(self, memory_id: str, **kw: Any) -> Dict[str, Any]:
+        res: Dict[str, Any] = self._t.call("kimetsu_brain_memory_invalidate", _clean({"memory_id": memory_id, **kw}))
+        return res
+
+    def blame(self, run_id: str, **kw: Any) -> Dict[str, Any]:
+        """Per-run citation attribution: which memories a run cited. Pass a run_id (ULID)."""
+        res: Dict[str, Any] = self._t.call("kimetsu_brain_memory_blame", _clean({"run_id": run_id, **kw}))
+        return res
+
+    def proposals(self, **kw: Any) -> Dict[str, Any]:
+        res: Dict[str, Any] = self._t.call("kimetsu_brain_memory_proposals", _clean(kw))
+        return res
+
+    def conflicts(self, **kw: Any) -> Dict[str, Any]:
+        res: Dict[str, Any] = self._t.call("kimetsu_brain_memory_conflicts", _clean(kw))
+        return res
+
+    def conflict_resolve(self, **kw: Any) -> Dict[str, Any]:
+        res: Dict[str, Any] = self._t.call("kimetsu_brain_conflict_resolve", _clean(kw))
+        return res
+
+    def prune(self, **kw: Any) -> Dict[str, Any]:
+        res: Dict[str, Any] = self._t.call("kimetsu_brain_prune", _clean(kw))
+        return res
+
+
+class _Config:
+    def __init__(self, t: Any) -> None:
+        self._t = t
+
+    def show(self, **kw: Any) -> Dict[str, Any]:
+        res: Dict[str, Any] = self._t.call("kimetsu_brain_config_show", _clean(kw))
+        return res
+
+
+class _Models:
+    def __init__(self, t: Any) -> None:
+        self._t = t
+
+    def list(self, **kw: Any) -> Dict[str, Any]:
+        res: Dict[str, Any] = self._t.call("kimetsu_brain_model_list", _clean(kw))
+        return res
+
+
+class _Benchmark:
+    def __init__(self, t: Any) -> None:
+        self._t = t
+
+    def context(self, query: str, **kw: Any) -> Dict[str, Any]:
+        res: Dict[str, Any] = self._t.call("kimetsu_benchmark_context", _clean({"query": query, **kw}))
+        return res
+
+    def record_outcome(self, task: str, **kw: Any) -> Dict[str, Any]:
+        res: Dict[str, Any] = self._t.call("kimetsu_benchmark_record_outcome", _clean({"task": task, **kw}))
+        return res
+
+
+class KimetsuClient:
+    def __init__(self, base_url: Optional[str] = None, token: Optional[str] = None,
+                 repo: Optional[str] = None, *, timeout: float = 30.0,
+                 transport: Optional[Any] = None) -> None:
+        if transport is not None:
+            self._t = transport
+        else:
+            base_url = base_url or os.environ["KIMETSU_REMOTE_URL"]
+            token = token or os.environ["KIMETSU_REMOTE_TOKEN"]
+            repo = repo or os.environ["KIMETSU_REMOTE_REPO"]
+            self._t = SyncTransport(base_url, token, repo, timeout=timeout)
+        self.memory = _Memory(self._t)
+        self.config = _Config(self._t)
+        self.models = _Models(self._t)
+        self.benchmark = _Benchmark(self._t)
+
+    def context(self, query: str, *, tags: Optional[List[str]] = None, **kw: Any) -> Context:
+        return Context.model_validate(
+            self._t.call("kimetsu_brain_context", _clean({"query": query, "tags": tags, **kw}))
+        )
+
+    def record(self, lesson: str, *, tags: List[str],
+               kind: Optional[str] = None, **kw: Any) -> Dict[str, Any]:
+        res: Dict[str, Any] = self._t.call(
+            "kimetsu_brain_record", _clean({"lesson": lesson, "tags": tags, "kind": kind, **kw})
+        )
+        return res
+
+    def status(self) -> Status:
+        return Status.model_validate(self._t.call("kimetsu_brain_status", {}))
+
+    def insights(self) -> Dict[str, Any]:
+        res: Dict[str, Any] = self._t.call("kimetsu_brain_insights", {})
+        return res
+
+    def close(self) -> None:
+        if hasattr(self._t, "close"):
+            self._t.close()
+
+    def __enter__(self) -> "KimetsuClient":
+        return self
+
+    def __exit__(self, *exc: Any) -> None:
+        self.close()

kimetsu/errors.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+from typing import Optional
+
+
+class KimetsuError(Exception):
+    """Base class for all Kimetsu SDK errors."""
+
+
+class KimetsuAuthError(KimetsuError):
+    """HTTP 401 (missing/invalid token) or 403 (wrong repo / scope)."""
+
+
+class KimetsuRateLimitError(KimetsuError):
+    """HTTP 429."""
+
+    def __init__(self, message: str, *, retry_after: Optional[float] = None) -> None:
+        super().__init__(message)
+        self.retry_after = retry_after
+
+
+class KimetsuToolError(KimetsuError):
+    """A JSON-RPC `error` object returned in the MCP envelope."""
+
+    def __init__(self, message: str, *, code: Optional[int] = None) -> None:
+        super().__init__(message)
+        self.code = code
+        self.message = message
+
+
+class KimetsuProtocolError(KimetsuError):
+    """Handshake failure or malformed JSON-RPC envelope."""

kimetsu/models.py

@@ -0,0 +1,22 @@
+from __future__ import annotations
+from typing import Any, Dict, List, Optional
+from pydantic import BaseModel, ConfigDict
+
+
+class _Base(BaseModel):
+    model_config = ConfigDict(extra="allow")
+
+
+class Memory(_Base):
+    id: Optional[str] = None
+    text: Optional[str] = None
+    tags: Optional[List[str]] = None
+
+
+class Context(_Base):
+    capsules: List[Dict[str, Any]] = []
+
+
+class Status(_Base):
+    initialized: Optional[bool] = None
+    accepted: Optional[int] = None

kimetsu-0.1.0.dist-info/METADATA

@@ -0,0 +1,124 @@
+Metadata-Version: 2.4
+Name: kimetsu
+Version: 0.1.0
+Summary: Typed Python client for the Kimetsu remote brain
+Project-URL: Homepage, https://github.com/RodCor/kimetsu-py
+Project-URL: Repository, https://github.com/RodCor/kimetsu-py
+Project-URL: Main project, https://github.com/RodCor/kimetsu
+Author: Rodrigo Cordoba
+License-Expression: MIT OR Apache-2.0
+License-File: LICENSE
+Keywords: agent,kimetsu,llm,mcp,memory,sdk
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Requires-Dist: httpx>=0.27
+Requires-Dist: pydantic>=2
+Provides-Extra: dev
+Requires-Dist: mypy; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.23; extra == 'dev'
+Requires-Dist: pytest>=8; extra == 'dev'
+Requires-Dist: respx>=0.21; extra == 'dev'
+Requires-Dist: ruff; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# kimetsu
+
+Typed Python client for the Kimetsu remote brain.
+
+## What it is
+
+A sync + async client over the Kimetsu remote brain's MCP JSON-RPC endpoint.
+Requires a running `kimetsu-remote` server; you supply its base URL, a bearer
+token, and the repo name.
+
+## Install
+
+```
+pip install kimetsu
+```
+
+## Quickstart (sync)
+
+```python
+from kimetsu import KimetsuClient
+
+client = KimetsuClient(base_url="https://brain.example.com", token="tok_...", repo="web")
+client.record("Use `just migrate`, never raw sqlx", tags=["db", "workflow"])
+ctx = client.context("how do we run migrations?", tags=["db"])
+print(ctx.capsules)
+```
+
+## Quickstart (async)
+
+```python
+import asyncio
+from kimetsu import AsyncKimetsuClient
+
+async def main():
+    async with AsyncKimetsuClient(base_url="https://brain.example.com", token="tok_...", repo="web") as client:
+        ctx = await client.context("how do we run migrations?", tags=["db"])
+        print(ctx.capsules)
+
+asyncio.run(main())
+```
+
+## Configuration / env vars
+
+`KIMETSU_REMOTE_URL`, `KIMETSU_REMOTE_TOKEN`, `KIMETSU_REMOTE_REPO` (used when
+the matching constructor arg is omitted). Optional `timeout` (default 30s).
+
+## API surface — method → remote tool
+
+| SDK call | Remote tool |
+| --- | --- |
+| `context` | `kimetsu_brain_context` |
+| `record` | `kimetsu_brain_record` |
+| `status` | `kimetsu_brain_status` |
+| `insights` | `kimetsu_brain_insights` |
+| `memory.search` | `kimetsu_brain_memory_search` |
+| `memory.add` | `kimetsu_brain_memory_add` |
+| `memory.list` | `kimetsu_brain_memory_list` |
+| `memory.top` | `kimetsu_brain_memory_top` |
+| `memory.accept` | `kimetsu_brain_memory_accept` |
+| `memory.reject` | `kimetsu_brain_memory_reject` |
+| `memory.invalidate` | `kimetsu_brain_memory_invalidate` |
+| `memory.blame` | `kimetsu_brain_memory_blame` (per-run citation attribution — pass a `run_id`, returns which memories that run cited) |
+| `memory.proposals` | `kimetsu_brain_memory_proposals` |
+| `memory.conflicts` | `kimetsu_brain_memory_conflicts` |
+| `memory.conflict_resolve` | `kimetsu_brain_conflict_resolve` |
+| `memory.prune` | `kimetsu_brain_prune` |
+| `config.show` | `kimetsu_brain_config_show` |
+| `models.list` | `kimetsu_brain_model_list` |
+| `benchmark.context` | `kimetsu_benchmark_context` |
+| `benchmark.record_outcome` | `kimetsu_benchmark_record_outcome` |
+
+(`AsyncKimetsuClient` mirrors every method with `await`.)
+
+Required arguments: `record` requires `tags`, `memory.add` requires `scope`,
+and `benchmark.record_outcome` requires `task` — all three raise `TypeError`
+if omitted, e.g. `client.benchmark.record_outcome(task="my-task", passed=True)`.
+
+## Errors
+
+All error types are exported from the top level: `from kimetsu import KimetsuAuthError`.
+
+`KimetsuError` (base), `KimetsuAuthError` (401/403), `KimetsuRateLimitError`
+(429, `.retry_after`), `KimetsuToolError` (JSON-RPC tool error, `.code`),
+`KimetsuProtocolError` (handshake/malformed envelope).
+
+## Typed returns
+
+`context`→`Context` (`.capsules`), `status`→`Status` (`.initialized`,
+`.accepted`), `memory.add`→`Memory` (`.id`, `.text`, `.tags`). Other methods
+return `dict`.
+
+## License
+
+MIT OR Apache-2.0.
+
+## Links
+
+Main project: https://github.com/RodCor/kimetsu

kimetsu-0.1.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+kimetsu/__init__.py,sha256=ClUo2u5NrEYBJHYn9VPEwZq56dHb235dp-zGs9GF1a4,534
+kimetsu/_transport.py,sha256=AJ7nJurvlhkd4Qi5W7ONB-qy8UUhi3elzMubtzaXrIA,5172
+kimetsu/async_client.py,sha256=xrFmyHDJv9ESsNGR4-wJiqnHRVEG641jDIMj6KvQ-Ho,5529
+kimetsu/client.py,sha256=Ypk6ZKCEhlxigau5ISE_WPX7-zuvf8EyBTS5dKjDP5E,5342
+kimetsu/errors.py,sha256=9ZJkrAIfJsTadOQbb867JbLjTC6TwewyLn2RJQGAIZc,860
+kimetsu/models.py,sha256=cYCfFEuYUuqPQnlIzp8tPwiUeZ3DEUTNWwcm5I0-0q0,475
+kimetsu/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+kimetsu-0.1.0.dist-info/METADATA,sha256=YjLWuHzHSzipVb5Xk44qgftrbT9qfsNhdPB0gQnueuU,4173
+kimetsu-0.1.0.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+kimetsu-0.1.0.dist-info/licenses/LICENSE,sha256=FhlD8Gb80t26OwsXm9p-SxRhNoNn4lznMl7LFMilrmc,7135
+kimetsu-0.1.0.dist-info/RECORD,,

kimetsu-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.31.0
+Root-Is-Purelib: true
+Tag: py3-none-any

kimetsu-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,150 @@
+Licensed under either of MIT or Apache-2.0 at your option.
+
+================================================================================
+MIT License
+================================================================================
+
+Copyright (c) 2026 RodCor
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+================================================================================
+Apache License
+Version 2.0, January 2004
+http://www.apache.org/licenses/
+================================================================================
+
+Copyright 2026 RodCor
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+"License" shall mean the terms and conditions for use, reproduction, and
+distribution as defined by Sections 1 through 9 of this document.
+
+"Licensor" shall mean the copyright owner or entity authorized by the
+copyright owner that is granting the License.
+
+"Legal Entity" shall mean the union of the acting entity and all other
+entities that control, are controlled by, or are under common control with
+that entity. For the purposes of this definition, "control" means (i) the
+power, direct or indirect, to cause the direction or management of such
+entity, whether by contract or otherwise, or (ii) ownership of fifty percent
+(50%) or more of the outstanding shares, or (iii) beneficial ownership of such
+entity.
+
+"You" (or "Your") shall mean an individual or Legal Entity exercising
+permissions granted by this License.
+
+"Source" form shall mean the preferred form for making modifications,
+including but not limited to software source code, documentation source, and
+configuration files.
+
+"Object" form shall mean any form resulting from mechanical transformation or
+translation of a Source form, including but not limited to compiled object
+code, generated documentation, and conversions to other media types.
+
+"Work" shall mean the work of authorship, whether in Source or Object form,
+made available under the License, as indicated by a copyright notice that is
+included in or attached to the work (an example is provided in the Appendix
+below).
+
+"Derivative Works" shall mean any work, whether in Source or Object form,
+that is based on (or derived from) the Work and for which the editorial
+revisions, annotations, elaborations, or other modifications represent, as a
+whole, an original work of authorship.
+
+"Contribution" shall mean any work of authorship, including the original
+version of the Work and any modifications or additions to that Work or
+Derivative Works thereof, that is intentionally submitted to Licensor for
+inclusion in the Work by the copyright owner or by an individual or Legal
+Entity authorized to submit on behalf of the copyright owner.
+
+"Contributor" shall mean Licensor and any individual or Legal Entity on
+behalf of whom a Contribution has been received by Licensor and subsequently
+incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of this
+License, each Contributor hereby grants to You a perpetual, worldwide,
+non-exclusive, no-charge, royalty-free, irrevocable copyright license to
+reproduce, prepare Derivative Works of, publicly display, publicly perform,
+sublicense, and distribute the Work and such Derivative Works in Source or
+Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of this
+License, each Contributor hereby grants to You a perpetual, worldwide,
+non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this
+section) patent license to make, have made, use, offer to sell, sell, import,
+and otherwise transfer the Work.
+
+4. Redistribution. You may reproduce and distribute copies of the Work or
+Derivative Works thereof in any medium, with or without modifications, and in
+Source or Object form, provided that You meet the following conditions:
+
+   (a) You must give any other recipients of the Work or Derivative Works a
+       copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices stating
+       that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works that You
+       distribute, all copyright, patent, trademark, and attribution notices
+       from the Source form of the Work; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained within
+       such NOTICE file.
+
+5. Submission of Contributions. Unless You explicitly state otherwise, any
+Contribution intentionally submitted for inclusion in the Work by You to the
+Licensor shall be under the terms and conditions of this License, without any
+additional terms or conditions.
+
+6. Trademarks. This License does not grant permission to use the trade
+names, trademarks, service marks, or product names of the Licensor.
+
+7. Disclaimer of Warranty. Unless required by applicable law or agreed to in
+writing, Licensor provides the Work on an "AS IS" BASIS, WITHOUT WARRANTIES
+OR CONDITIONS OF ANY KIND, either express or implied.
+
+8. Limitation of Liability. In no event and under no legal theory shall any
+Contributor be liable to You for damages, including any direct, indirect,
+special, incidental, or consequential damages arising as a result of this
+License.
+
+9. Accepting Warranty or Additional Liability. While redistributing the Work
+or Derivative Works thereof, You may choose to offer, and charge a fee for,
+acceptance of support, warranty, indemnity, or other liability obligations
+consistent with this License.
+
+END OF TERMS AND CONDITIONS