asymmetric-py 0.1.0__tar.gz

asymmetric_py-0.1.0/.gitignore

@@ -0,0 +1,7 @@
+.env
+.venv/
+__pycache__/
+*.py[cod]
+.pytest_cache/
+dist/*
+!dist/.gitignore

asymmetric_py-0.1.0/LICENSE

@@ -0,0 +1,85 @@
+PolyForm Noncommercial License 1.0.0
+
+Acceptance
+
+In order to get any license under these terms, you must agree
+to them as both strict obligations and conditions to all your
+licenses.
+
+Copyright License
+
+The licensor grants you a copyright license for the software to
+do everything you might do with the software that would otherwise
+infringe the licensor's copyright in it for any permitted purpose.
+
+Patent License
+
+The licensor grants you a patent license for the software that
+covers patent claims the licensor can license, or becomes able to
+license, that you would otherwise infringe by using the software
+for any permitted purpose.
+
+Noncommercial Purposes
+
+Any noncommercial purpose is a permitted purpose.
+
+Distribution
+
+You may distribute copies of the software.
+
+Conditions
+
+Your licenses are subject to the following conditions:
+
+No Trademark License
+
+Neither this license nor any other license granted under these
+terms gives you any right in the licensor's trademarks or any
+other rights in the licensor's name, logo, or brand.
+
+Notices
+
+You must ensure that anyone who gets a copy of any part of the
+software from you also gets a copy of these terms or a link to
+<https://polyformproject.org/licenses/noncommercial/1.0.0>.
+
+Changes
+
+You must not remove any copyright notice from the software.
+
+You must cause any modified files to carry prominent notices
+stating that you changed the files.
+
+No Compensation
+
+You may not use this software or provide it to others for
+compensation or other consideration.
+
+If you are already using this software for compensation or other
+consideration, you must stop.
+
+Excuse
+
+If anyone notifies you in writing that you have not complied with
+No Compensation, you can keep your license by taking all practical
+steps to comply within 32 days after the notice. Otherwise, your
+license ends immediately.
+
+Patent Defense
+
+If you make any written claim that the software infringes or
+contributes to infringement of any patent, your patent license
+for the software ends immediately. If your company makes such a
+claim, your patent license ends immediately for work on behalf of
+your company.
+
+Violations
+
+If you violate these terms, your licenses end immediately.
+
+No Liability
+
+As far as the law allows, the software comes as is, without any
+warranty or condition, and the licensor will not be liable to you
+for any damages arising out of these terms or the use or nature of
+the software, under any kind of legal claim.

asymmetric_py-0.1.0/PKG-INFO

@@ -0,0 +1,234 @@
+Metadata-Version: 2.4
+Name: asymmetric-py
+Version: 0.1.0
+Summary: Lightweight Python SDK for the Asymmetric API
+Project-URL: Homepage, https://github.com/asymmetric-dev/asymmetric-py
+Project-URL: Repository, https://github.com/asymmetric-dev/asymmetric-py
+Project-URL: Issues, https://github.com/asymmetric-dev/asymmetric-py/issues
+Author: Asymmetric
+License: PolyForm Noncommercial License 1.0.0
+        
+        Acceptance
+        
+        In order to get any license under these terms, you must agree
+        to them as both strict obligations and conditions to all your
+        licenses.
+        
+        Copyright License
+        
+        The licensor grants you a copyright license for the software to
+        do everything you might do with the software that would otherwise
+        infringe the licensor's copyright in it for any permitted purpose.
+        
+        Patent License
+        
+        The licensor grants you a patent license for the software that
+        covers patent claims the licensor can license, or becomes able to
+        license, that you would otherwise infringe by using the software
+        for any permitted purpose.
+        
+        Noncommercial Purposes
+        
+        Any noncommercial purpose is a permitted purpose.
+        
+        Distribution
+        
+        You may distribute copies of the software.
+        
+        Conditions
+        
+        Your licenses are subject to the following conditions:
+        
+        No Trademark License
+        
+        Neither this license nor any other license granted under these
+        terms gives you any right in the licensor's trademarks or any
+        other rights in the licensor's name, logo, or brand.
+        
+        Notices
+        
+        You must ensure that anyone who gets a copy of any part of the
+        software from you also gets a copy of these terms or a link to
+        <https://polyformproject.org/licenses/noncommercial/1.0.0>.
+        
+        Changes
+        
+        You must not remove any copyright notice from the software.
+        
+        You must cause any modified files to carry prominent notices
+        stating that you changed the files.
+        
+        No Compensation
+        
+        You may not use this software or provide it to others for
+        compensation or other consideration.
+        
+        If you are already using this software for compensation or other
+        consideration, you must stop.
+        
+        Excuse
+        
+        If anyone notifies you in writing that you have not complied with
+        No Compensation, you can keep your license by taking all practical
+        steps to comply within 32 days after the notice. Otherwise, your
+        license ends immediately.
+        
+        Patent Defense
+        
+        If you make any written claim that the software infringes or
+        contributes to infringement of any patent, your patent license
+        for the software ends immediately. If your company makes such a
+        claim, your patent license ends immediately for work on behalf of
+        your company.
+        
+        Violations
+        
+        If you violate these terms, your licenses end immediately.
+        
+        No Liability
+        
+        As far as the law allows, the software comes as is, without any
+        warranty or condition, and the licensor will not be liable to you
+        for any damages arising out of these terms or the use or nature of
+        the software, under any kind of legal claim.
+License-File: LICENSE
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Requires-Dist: httpx>=0.27
+Requires-Dist: python-dotenv>=1.0
+Description-Content-Type: text/markdown
+
+<h1 align="center">asymmetric-py</h1>
+
+
+## Install
+
+```bash
+pip install asymmetric-py
+```
+
+Or install from source:
+
+```bash
+git clone https://github.com/asymmetric-dev/asymmetric-py.git
+cd asymmetric-py
+pip install .
+```
+
+## Publishing
+
+See [PUBLISH.md](PUBLISH.md).
+
+## Usage
+
+```python
+from asymmetric import Asymmetric, GuardrailViolation
+
+client = Asymmetric(api_key="sk_live_...")
+```
+
+### Guardrails ([example](examples/guardrails.py))
+
+```python
+try:
+    response = client.chat.completions.create(
+        model="openai/gpt-4o-mini",
+        messages=[{"role": "user", "content": "Tell me about Caltech"}],
+        guardrail_policy="Flag any content mentioning Caltech",
+    )
+    print(response.choices[0].message.content)
+except GuardrailViolation as e:
+    print(e.policy)
+```
+
+### Streaming ([example](examples/streaming.py))
+
+```python
+try:
+    for chunk in client.chat.completions.create(
+        model="openai/gpt-4o-mini",
+        messages=[{"role": "user", "content": "Tell me about Caltech"}],
+        guardrail_policy="Flag any content mentioning Caltech",
+        stream=True,
+    ):
+        if chunk.choices[0].delta.content:
+            print(chunk.choices[0].delta.content, end="")
+except GuardrailViolation as e:
+    print(f"\nViolation: {e.policy}")
+```
+
+### Multiple policies ([example](examples/multiple_policies.py))
+
+```python
+response = client.chat.completions.create(
+    model="openai/gpt-4o-mini",
+    messages=[{"role": "user", "content": "Hello"}],
+    guardrail_policy=[
+        "Flag any content promoting violence",
+        "Flag any content containing profanity",
+    ],
+)
+```
+
+### Violation history ([example](examples/violations.py))
+
+```python
+violations = client.guardrails.list_violations()
+for v in violations:
+    print(v.timestamp, v.guardrail_policy)
+```
+
+### Finetuning ([example](examples/finetuning.py))
+
+```python
+# Trigger training
+job = client.finetuning.train(
+    memory_group="darwin_agent",
+    lora_name="darwin_adapter",
+)
+print(job.status, job.message)
+
+# Check status
+status = client.finetuning.status(
+    memory_group="darwin_agent",
+    lora_name="darwin_adapter",
+)
+print(f"Ready: {status.lora_ready}")
+
+# List all adapters
+adapters = client.finetuning.list()
+for a in adapters:
+    print(f"{a.lora_name}: {a.status}")
+```
+
+### LoRA inference ([example](examples/finetuning.py))
+
+```python
+response = client.chat.completions.create(
+    model="asymmetric/Qwen3-8B",
+    messages=[{"role": "user", "content": "Tell me about Darwin's voyages"}],
+    finetuning={"lora_name": "darwin_adapter"},
+)
+print(response.choices[0].message.content)
+```
+
+### Auto-training with memory ([example](examples/finetuning_with_memory.py))
+
+```python
+response = client.chat.completions.create(
+    model="openai/gpt-4o-mini",
+    messages=[{"role": "user", "content": "What did Darwin discover?"}],
+    memory=[{"group": "darwin_agent", "goal": "Historical records about Darwin"}],
+    finetuning={
+        "lora_name": "darwin_adapter",
+        "finetune_thresh": 3,
+        "min_finetune_group": 5,
+    },
+)
+```

asymmetric_py-0.1.0/PUBLISH.md

@@ -0,0 +1,25 @@
+# Publishing
+
+Build the package locally before uploading:
+
+```bash
+uv build --no-sources
+```
+
+This writes a wheel and source distribution to `dist/`. Check those files before publishing.
+
+## TestPyPI
+
+```bash
+export UV_PUBLISH_TOKEN=pypi-...
+uv publish \
+  --publish-url https://test.pypi.org/legacy/ \
+  --check-url https://test.pypi.org/simple/
+```
+
+## PyPI
+
+```bash
+export UV_PUBLISH_TOKEN=pypi-...
+uv publish
+```

asymmetric_py-0.1.0/README.md

@@ -0,0 +1,128 @@
+<h1 align="center">asymmetric-py</h1>
+
+
+## Install
+
+```bash
+pip install asymmetric-py
+```
+
+Or install from source:
+
+```bash
+git clone https://github.com/asymmetric-dev/asymmetric-py.git
+cd asymmetric-py
+pip install .
+```
+
+## Publishing
+
+See [PUBLISH.md](PUBLISH.md).
+
+## Usage
+
+```python
+from asymmetric import Asymmetric, GuardrailViolation
+
+client = Asymmetric(api_key="sk_live_...")
+```
+
+### Guardrails ([example](examples/guardrails.py))
+
+```python
+try:
+    response = client.chat.completions.create(
+        model="openai/gpt-4o-mini",
+        messages=[{"role": "user", "content": "Tell me about Caltech"}],
+        guardrail_policy="Flag any content mentioning Caltech",
+    )
+    print(response.choices[0].message.content)
+except GuardrailViolation as e:
+    print(e.policy)
+```
+
+### Streaming ([example](examples/streaming.py))
+
+```python
+try:
+    for chunk in client.chat.completions.create(
+        model="openai/gpt-4o-mini",
+        messages=[{"role": "user", "content": "Tell me about Caltech"}],
+        guardrail_policy="Flag any content mentioning Caltech",
+        stream=True,
+    ):
+        if chunk.choices[0].delta.content:
+            print(chunk.choices[0].delta.content, end="")
+except GuardrailViolation as e:
+    print(f"\nViolation: {e.policy}")
+```
+
+### Multiple policies ([example](examples/multiple_policies.py))
+
+```python
+response = client.chat.completions.create(
+    model="openai/gpt-4o-mini",
+    messages=[{"role": "user", "content": "Hello"}],
+    guardrail_policy=[
+        "Flag any content promoting violence",
+        "Flag any content containing profanity",
+    ],
+)
+```
+
+### Violation history ([example](examples/violations.py))
+
+```python
+violations = client.guardrails.list_violations()
+for v in violations:
+    print(v.timestamp, v.guardrail_policy)
+```
+
+### Finetuning ([example](examples/finetuning.py))
+
+```python
+# Trigger training
+job = client.finetuning.train(
+    memory_group="darwin_agent",
+    lora_name="darwin_adapter",
+)
+print(job.status, job.message)
+
+# Check status
+status = client.finetuning.status(
+    memory_group="darwin_agent",
+    lora_name="darwin_adapter",
+)
+print(f"Ready: {status.lora_ready}")
+
+# List all adapters
+adapters = client.finetuning.list()
+for a in adapters:
+    print(f"{a.lora_name}: {a.status}")
+```
+
+### LoRA inference ([example](examples/finetuning.py))
+
+```python
+response = client.chat.completions.create(
+    model="asymmetric/Qwen3-8B",
+    messages=[{"role": "user", "content": "Tell me about Darwin's voyages"}],
+    finetuning={"lora_name": "darwin_adapter"},
+)
+print(response.choices[0].message.content)
+```
+
+### Auto-training with memory ([example](examples/finetuning_with_memory.py))
+
+```python
+response = client.chat.completions.create(
+    model="openai/gpt-4o-mini",
+    messages=[{"role": "user", "content": "What did Darwin discover?"}],
+    memory=[{"group": "darwin_agent", "goal": "Historical records about Darwin"}],
+    finetuning={
+        "lora_name": "darwin_adapter",
+        "finetune_thresh": 3,
+        "min_finetune_group": 5,
+    },
+)
+```

asymmetric_py-0.1.0/asymmetric/__init__.py

@@ -0,0 +1,31 @@
+from .client import Asymmetric
+from .types import (
+    ChatCompletion,
+    ChatCompletionChunk,
+    Choice,
+    Delta,
+    GuardrailViolation,
+    LoraAdapter,
+    Message,
+    StreamChoice,
+    TrainingJob,
+    TrainingStatus,
+    Usage,
+    Violation,
+)
+
+__all__ = [
+    "Asymmetric",
+    "ChatCompletion",
+    "ChatCompletionChunk",
+    "Choice",
+    "Delta",
+    "GuardrailViolation",
+    "LoraAdapter",
+    "Message",
+    "StreamChoice",
+    "TrainingJob",
+    "TrainingStatus",
+    "Usage",
+    "Violation",
+]

asymmetric_py-0.1.0/asymmetric/client.py

@@ -0,0 +1,291 @@
+from __future__ import annotations
+
+import json
+from typing import Any, Iterator, Literal, overload
+
+import httpx
+
+from .types import (
+    ChatCompletion,
+    ChatCompletionChunk,
+    Choice,
+    Delta,
+    GuardrailViolation,
+    LoraAdapter,
+    Message,
+    StreamChoice,
+    TrainingJob,
+    TrainingStatus,
+    Usage,
+    Violation,
+)
+
+_DEFAULT_BASE_URL = "https://rkdune--symmetry.modal.run"
+
+
+class Asymmetric:
+    """Asymmetric API client with guardrail support."""
+
+    def __init__(
+        self,
+        api_key: str,
+        base_url: str = _DEFAULT_BASE_URL,
+        timeout: float = 120.0,
+    ) -> None:
+        self._http = httpx.Client(
+            base_url=base_url.rstrip("/"),
+            headers={
+                "Authorization": f"Bearer {api_key}",
+                "Content-Type": "application/json",
+            },
+            timeout=timeout,
+        )
+        self.chat = _Chat(self)
+        self.guardrails = _Guardrails(self)
+        self.finetuning = _Finetuning(self)
+
+    def close(self) -> None:
+        self._http.close()
+
+    def __enter__(self) -> Asymmetric:
+        return self
+
+    def __exit__(self, *args: Any) -> None:
+        self.close()
+
+
+class _Chat:
+    def __init__(self, client: Asymmetric) -> None:
+        self.completions = _Completions(client)
+
+
+class _Completions:
+    def __init__(self, client: Asymmetric) -> None:
+        self._client = client
+
+    @overload
+    def create(
+        self,
+        *,
+        model: str,
+        messages: list[dict[str, str]],
+        stream: Literal[False] = ...,
+        guardrail_policy: str | list[str] | None = ...,
+        chunk_size: int = ...,
+        sliding_window: int = ...,
+        finetuning: dict[str, Any] | None = ...,
+        **kwargs: Any,
+    ) -> ChatCompletion: ...
+
+    @overload
+    def create(
+        self,
+        *,
+        model: str,
+        messages: list[dict[str, str]],
+        stream: Literal[True],
+        guardrail_policy: str | list[str] | None = ...,
+        chunk_size: int = ...,
+        sliding_window: int = ...,
+        finetuning: dict[str, Any] | None = ...,
+        **kwargs: Any,
+    ) -> Iterator[ChatCompletionChunk]: ...
+
+    def create(
+        self,
+        *,
+        model: str,
+        messages: list[dict[str, str]],
+        stream: bool = False,
+        guardrail_policy: str | list[str] | None = None,
+        chunk_size: int = 10,
+        sliding_window: int = 5,
+        finetuning: dict[str, Any] | None = None,
+        **kwargs: Any,
+    ) -> ChatCompletion | Iterator[ChatCompletionChunk]:
+        body: dict[str, Any] = {
+            "model": model,
+            "messages": messages,
+            "stream": stream,
+            **kwargs,
+        }
+        if guardrail_policy is not None:
+            body["guardrail_policy"] = guardrail_policy
+            body["chunk_size"] = chunk_size
+            body["sliding_window"] = sliding_window
+        if finetuning is not None:
+            body.update(finetuning)
+
+        if stream:
+            return self._stream(body)
+        return self._complete(body)
+
+    def _complete(self, body: dict[str, Any]) -> ChatCompletion:
+        resp = self._client._http.post("/v1/chat/completions", json=body)
+        if resp.status_code == 400:
+            detail = resp.json().get("detail", "")
+            if "Guardrail violation" in detail:
+                raise _parse_violation(detail)
+        resp.raise_for_status()
+        return _build_completion(resp.json())
+
+    def _stream(
+        self, body: dict[str, Any]
+    ) -> Iterator[ChatCompletionChunk]:
+        with self._client._http.stream(
+            "POST", "/v1/chat/completions", json=body
+        ) as resp:
+            resp.raise_for_status()
+            for line in resp.iter_lines():
+                if not line.startswith("data: "):
+                    continue
+                payload = line[6:]
+                if payload == "[DONE]":
+                    return
+                data = json.loads(payload)
+                if "error" in data:
+                    msg = data["error"]
+                    if "Guardrail violation" in msg:
+                        raise _parse_violation(msg)
+                    raise RuntimeError(msg)
+                yield _build_chunk(data)
+
+
+class _Guardrails:
+    def __init__(self, client: Asymmetric) -> None:
+        self._client = client
+
+    def list_violations(self) -> list[Violation]:
+        resp = self._client._http.get("/guardrail/violations")
+        resp.raise_for_status()
+        return [
+            Violation(
+                id=v["id"],
+                timestamp=v["timestamp"],
+                user_input=v.get("user_input"),
+                model_output=v["model_output"],
+                guardrail_policy=v["guardrail_policy"],
+            )
+            for v in resp.json().get("violations", [])
+        ]
+
+
+class _Finetuning:
+    def __init__(self, client: Asymmetric) -> None:
+        self._client = client
+
+    def train(self, memory_group: str, lora_name: str) -> TrainingJob:
+        resp = self._client._http.post(
+            "/finetuning/train",
+            json={"memory_group": memory_group, "lora_name": lora_name},
+        )
+        resp.raise_for_status()
+        data = resp.json()
+        return TrainingJob(
+            status=data["status"],
+            message=data["message"],
+            lora_name=data.get("lora_name"),
+            version=data.get("version"),
+            memories_count=data.get("memories_count"),
+            job_id=data.get("job_id"),
+        )
+
+    def status(self, memory_group: str, lora_name: str) -> TrainingStatus:
+        resp = self._client._http.get(
+            "/finetuning/status",
+            params={"memory_group": memory_group, "lora_name": lora_name},
+        )
+        resp.raise_for_status()
+        data = resp.json()
+        return TrainingStatus(
+            memory_group=data["memory_group"],
+            lora_name=data["lora_name"],
+            queued_count=data["queued_count"],
+            trained_count=data["trained_count"],
+            training_status=data["training_status"],
+            current_version=data["current_version"],
+            last_training_started=data.get("last_training_started"),
+            last_training_completed=data.get("last_training_completed"),
+            last_error=data.get("last_error"),
+            lora_status=data.get("lora_status"),
+            lora_ready=data["lora_ready"],
+        )
+
+    def list(self) -> list[LoraAdapter]:
+        resp = self._client._http.get("/finetuning/loras")
+        resp.raise_for_status()
+        return [
+            LoraAdapter(
+                lora_name=a["lora_name"],
+                memory_group=a["memory_group"],
+                status=a["status"],
+                active_version=a["active_version"],
+                created_at=a["created_at"],
+                updated_at=a["updated_at"],
+            )
+            for a in resp.json().get("loras", [])
+        ]
+
+
+# --- Helpers ---
+
+
+def _parse_violation(detail: str) -> GuardrailViolation:
+    """Parse violation detail string from the API."""
+    policy = ""
+    text = ""
+    try:
+        if "Policy: '" in detail:
+            after = detail.split("Policy: '", 1)[1]
+            policy = after.split("'. ", 1)[0]
+        for marker in ("Text in violation: '", "Text: '"):
+            if marker in detail:
+                raw = detail.split(marker, 1)[1]
+                text = raw[:-1] if raw.endswith("'") else raw
+                break
+    except (IndexError, ValueError):
+        pass
+    return GuardrailViolation(policy=policy, text=text)
+
+
+def _build_completion(data: dict[str, Any]) -> ChatCompletion:
+    choices = [
+        Choice(
+            index=c.get("index", i),
+            message=Message(
+                role=c["message"]["role"],
+                content=c["message"].get("content"),
+            ),
+            finish_reason=c.get("finish_reason"),
+        )
+        for i, c in enumerate(data["choices"])
+    ]
+    usage = None
+    if u := data.get("usage"):
+        usage = Usage(
+            prompt_tokens=u.get("prompt_tokens", 0),
+            completion_tokens=u.get("completion_tokens", 0),
+            total_tokens=u.get("total_tokens", 0),
+        )
+    return ChatCompletion(
+        id=data["id"], model=data["model"], choices=choices, usage=usage
+    )
+
+
+def _build_chunk(data: dict[str, Any]) -> ChatCompletionChunk:
+    choices = [
+        StreamChoice(
+            index=c.get("index", i),
+            delta=Delta(
+                role=c.get("delta", {}).get("role"),
+                content=c.get("delta", {}).get("content"),
+            ),
+            finish_reason=c.get("finish_reason"),
+        )
+        for i, c in enumerate(data.get("choices", []))
+    ]
+    return ChatCompletionChunk(
+        id=data.get("id", ""),
+        model=data.get("model", ""),
+        choices=choices,
+    )

asymmetric_py-0.1.0/asymmetric/types.py

@@ -0,0 +1,102 @@
+from dataclasses import dataclass
+
+
+class GuardrailViolation(Exception):
+    """Raised when a guardrail policy violation is detected."""
+
+    def __init__(self, policy: str, text: str) -> None:
+        self.policy = policy
+        self.text = text
+        super().__init__(f"Guardrail violation detected. Policy: '{policy}'")
+
+
+@dataclass
+class Message:
+    role: str
+    content: str | None = None
+
+
+@dataclass
+class Delta:
+    role: str | None = None
+    content: str | None = None
+
+
+@dataclass
+class Choice:
+    index: int
+    message: Message
+    finish_reason: str | None = None
+
+
+@dataclass
+class StreamChoice:
+    index: int
+    delta: Delta
+    finish_reason: str | None = None
+
+
+@dataclass
+class Usage:
+    prompt_tokens: int
+    completion_tokens: int
+    total_tokens: int
+
+
+@dataclass
+class ChatCompletion:
+    id: str
+    model: str
+    choices: list[Choice]
+    usage: Usage | None = None
+
+
+@dataclass
+class ChatCompletionChunk:
+    id: str
+    model: str
+    choices: list[StreamChoice]
+
+
+@dataclass
+class Violation:
+    id: str
+    timestamp: str
+    user_input: str | None
+    model_output: str
+    guardrail_policy: str
+
+
+@dataclass
+class TrainingJob:
+    status: str
+    message: str
+    lora_name: str | None = None
+    version: int | None = None
+    memories_count: int | None = None
+    job_id: str | None = None
+
+
+@dataclass
+class TrainingStatus:
+    memory_group: str
+    lora_name: str
+    queued_count: int
+    trained_count: int
+    training_status: str
+    current_version: int
+    last_training_started: int | None
+    last_training_completed: int | None
+    last_error: str | None
+    lora_status: str | None
+    lora_ready: bool
+
+
+@dataclass
+class LoraAdapter:
+    lora_name: str
+    memory_group: str
+    status: str
+    active_version: int
+    created_at: int
+    updated_at: int

asymmetric_py-0.1.0/pyproject.toml

@@ -0,0 +1,47 @@
+[project]
+name = "asymmetric-py"
+version = "0.1.0"
+description = "Lightweight Python SDK for the Asymmetric API"
+requires-python = ">=3.10"
+dependencies = ["httpx>=0.27", "python-dotenv>=1.0"]
+readme = "README.md"
+authors = [{ name = "Asymmetric" }]
+license = { file = "LICENSE" }
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+]
+
+[project.urls]
+Homepage = "https://github.com/asymmetric-dev/asymmetric-py"
+Repository = "https://github.com/asymmetric-dev/asymmetric-py"
+Issues = "https://github.com/asymmetric-dev/asymmetric-py/issues"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[dependency-groups]
+dev = ["pytest>=8.0"]
+
+[tool.hatch.build.targets.sdist]
+include = [
+    "/asymmetric",
+    "/tests",
+    "/README.md",
+    "/PUBLISH.md",
+    "/pyproject.toml",
+    "/LICENSE",
+]
+exclude = ["/.gitignore"]
+
+[tool.hatch.build.targets.wheel]
+packages = ["asymmetric"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

asymmetric_py-0.1.0/tests/test_client.py

@@ -0,0 +1,197 @@
+import json
+
+import httpx
+import pytest
+
+from asymmetric import Asymmetric, GuardrailViolation
+
+
+def make_client(handler):
+    client = Asymmetric(api_key="test-key", base_url="https://api.example.com/")
+    client._http.close()
+    client._http = httpx.Client(
+        transport=httpx.MockTransport(handler),
+        base_url="https://api.example.com",
+        headers={
+            "Authorization": "Bearer test-key",
+            "Content-Type": "application/json",
+        },
+    )
+    return client
+
+
+def test_chat_completion_builds_expected_request():
+    def handler(request: httpx.Request) -> httpx.Response:
+        assert request.method == "POST"
+        assert str(request.url) == "https://api.example.com/v1/chat/completions"
+        assert request.headers["Authorization"] == "Bearer test-key"
+
+        body = json.loads(request.content)
+        assert body == {
+            "model": "openai/gpt-4o-mini",
+            "messages": [{"role": "user", "content": "Hello"}],
+            "stream": False,
+            "temperature": 0.2,
+            "guardrail_policy": "No secrets",
+            "chunk_size": 12,
+            "sliding_window": 3,
+            "lora_name": "adapter-v1",
+        }
+
+        return httpx.Response(
+            200,
+            json={
+                "id": "chatcmpl_123",
+                "model": "openai/gpt-4o-mini",
+                "choices": [
+                    {
+                        "message": {"role": "assistant", "content": "Hi"},
+                        "finish_reason": "stop",
+                    }
+                ],
+                "usage": {
+                    "prompt_tokens": 1,
+                    "completion_tokens": 1,
+                    "total_tokens": 2,
+                },
+            },
+        )
+
+    client = make_client(handler)
+
+    try:
+        completion = client.chat.completions.create(
+            model="openai/gpt-4o-mini",
+            messages=[{"role": "user", "content": "Hello"}],
+            guardrail_policy="No secrets",
+            chunk_size=12,
+            sliding_window=3,
+            finetuning={"lora_name": "adapter-v1"},
+            temperature=0.2,
+        )
+    finally:
+        client.close()
+
+    assert completion.choices[0].message.content == "Hi"
+    assert completion.usage is not None
+    assert completion.usage.total_tokens == 2
+
+
+def test_chat_completion_raises_guardrail_violation():
+    def handler(request: httpx.Request) -> httpx.Response:
+        return httpx.Response(
+            400,
+            json={
+                "detail": "Guardrail violation detected. Policy: 'No secrets'. "
+                "Text in violation: 'secret token'"
+            },
+        )
+
+    client = make_client(handler)
+
+    try:
+        with pytest.raises(GuardrailViolation) as exc_info:
+            client.chat.completions.create(
+                model="openai/gpt-4o-mini",
+                messages=[{"role": "user", "content": "Hello"}],
+            )
+    finally:
+        client.close()
+
+    assert exc_info.value.policy == "No secrets"
+    assert exc_info.value.text == "secret token"
+
+
+def test_streaming_chat_completion_yields_chunks():
+    payload = (
+        'data: {"id":"chatcmpl_123","model":"openai/gpt-4o-mini",'
+        '"choices":[{"delta":{"role":"assistant","content":"Hi"}}]}\n\n'
+        'data: {"id":"chatcmpl_123","model":"openai/gpt-4o-mini",'
+        '"choices":[{"delta":{"content":" there"},"finish_reason":"stop"}]}\n\n'
+        "data: [DONE]\n\n"
+    )
+
+    def handler(request: httpx.Request) -> httpx.Response:
+        return httpx.Response(200, text=payload)
+
+    client = make_client(handler)
+
+    try:
+        chunks = list(
+            client.chat.completions.create(
+                model="openai/gpt-4o-mini",
+                messages=[{"role": "user", "content": "Hello"}],
+                stream=True,
+            )
+        )
+    finally:
+        client.close()
+
+    assert [chunk.choices[0].delta.content for chunk in chunks] == ["Hi", " there"]
+    assert chunks[0].choices[0].delta.role == "assistant"
+    assert chunks[-1].choices[0].finish_reason == "stop"
+
+
+def test_list_violations_parses_response():
+    def handler(request: httpx.Request) -> httpx.Response:
+        assert request.method == "GET"
+        assert str(request.url) == "https://api.example.com/guardrail/violations"
+        return httpx.Response(
+            200,
+            json={
+                "violations": [
+                    {
+                        "id": "vio_123",
+                        "timestamp": "2026-04-04T12:00:00Z",
+                        "user_input": "hello",
+                        "model_output": "blocked",
+                        "guardrail_policy": "No secrets",
+                    }
+                ]
+            },
+        )
+
+    client = make_client(handler)
+
+    try:
+        violations = client.guardrails.list_violations()
+    finally:
+        client.close()
+
+    assert len(violations) == 1
+    assert violations[0].guardrail_policy == "No secrets"
+
+
+def test_finetuning_status_parses_response():
+    def handler(request: httpx.Request) -> httpx.Response:
+        assert request.method == "GET"
+        assert str(request.url) == (
+            "https://api.example.com/finetuning/status"
+            "?memory_group=darwin&lora_name=adapter-v1"
+        )
+        return httpx.Response(
+            200,
+            json={
+                "memory_group": "darwin",
+                "lora_name": "adapter-v1",
+                "queued_count": 1,
+                "trained_count": 4,
+                "training_status": "ready",
+                "current_version": 2,
+                "last_training_started": 10,
+                "last_training_completed": 20,
+                "last_error": None,
+                "lora_status": "ready",
+                "lora_ready": True,
+            },
+        )
+
+    client = make_client(handler)
+
+    try:
+        status = client.finetuning.status("darwin", "adapter-v1")
+    finally:
+        client.close()
+
+    assert status.current_version == 2
+    assert status.lora_ready is True