kynth 0.1.0__py3-none-any.whl

kynth/__init__.py

@@ -0,0 +1,199 @@
+"""Official Python SDK for Kynth Core — the AI back-end for your product.
+
+    from kynth import Kynth, KynthError
+
+    client = Kynth(api_key="ksk_live_...")
+    doc = client.parse(file_url="https://.../invoice.pdf")
+    print(doc["totalAmount"], doc["usage"]["balanceRemaining"])
+
+Zero dependencies (stdlib only). Every method returns the endpoint result as a
+dict including a ``usage`` envelope; failures raise a typed ``KynthError`` and
+never burn credits. Get a key + 500 free credits at https://api.kynth.studio.
+"""
+
+from __future__ import annotations
+
+import json
+import urllib.error
+import urllib.request
+from typing import Any, Dict, List, Optional
+
+__all__ = ["Kynth", "KynthError", "__version__"]
+__version__ = "0.1.0"
+
+_DEFAULT_BASE_URL = "https://api.kynth.studio"
+
+
+class KynthError(Exception):
+    """Raised for any non-2xx API response. Mirrors ``{"error": {"code", "message"}}``."""
+
+    def __init__(self, code: str, message: str, status: int) -> None:
+        super().__init__(message)
+        self.code = code
+        self.message = message
+        self.status = status
+
+    def __repr__(self) -> str:  # pragma: no cover - trivial
+        return f"KynthError(code={self.code!r}, status={self.status}, message={self.message!r})"
+
+
+def _document(file_url: Optional[str], text: Optional[str], file: Optional[Dict[str, str]]) -> Dict[str, Any]:
+    if file_url:
+        return {"fileUrl": file_url}
+    if file:
+        return {"file": file}
+    if text:
+        return {"text": text}
+    raise ValueError("Provide one of: file_url, text, or file={'data','mimeType'}.")
+
+
+class Kynth:
+    """Synchronous client for the Kynth Core API."""
+
+    def __init__(
+        self,
+        api_key: str,
+        base_url: str = _DEFAULT_BASE_URL,
+        timeout: float = 60.0,
+    ) -> None:
+        if not api_key:
+            raise ValueError(
+                "Kynth: `api_key` is required. Mint one at https://api.kynth.studio/dashboard."
+            )
+        self.api_key = api_key
+        self.base_url = base_url.rstrip("/")
+        self.timeout = timeout
+
+    # -- transport ---------------------------------------------------------
+    def _request(self, method: str, path: str, body: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+        url = f"{self.base_url}{path}"
+        data = json.dumps(body).encode("utf-8") if body is not None else None
+        headers = {"Authorization": f"Bearer {self.api_key}"}
+        if data is not None:
+            headers["Content-Type"] = "application/json"
+        req = urllib.request.Request(url, data=data, headers=headers, method=method)
+        try:
+            with urllib.request.urlopen(req, timeout=self.timeout) as resp:
+                payload = resp.read().decode("utf-8")
+                return json.loads(payload) if payload else {}
+        except urllib.error.HTTPError as exc:
+            raw = exc.read().decode("utf-8", errors="replace")
+            code, message = "unknown", f"Request failed with status {exc.code}."
+            try:
+                err = json.loads(raw).get("error") or {}
+                code = err.get("code", code)
+                message = err.get("message", message)
+            except (ValueError, AttributeError):
+                pass
+            raise KynthError(code, message, exc.code) from None
+        except urllib.error.URLError as exc:
+            raise KynthError("unknown", str(exc.reason), 0) from None
+
+    def _post(self, path: str, body: Dict[str, Any]) -> Dict[str, Any]:
+        # Drop None values so optional params are omitted.
+        clean = {k: v for k, v in body.items() if v is not None}
+        return self._request("POST", path, clean)
+
+    # -- capabilities ------------------------------------------------------
+    def parse(
+        self,
+        *,
+        file_url: Optional[str] = None,
+        text: Optional[str] = None,
+        file: Optional[Dict[str, str]] = None,
+        doc_type: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """Parse a document (PDF/image/text) into structured, validated JSON."""
+        body = _document(file_url, text, file)
+        if doc_type:
+            body["docType"] = doc_type
+        return self._post("/v1/parse", body)
+
+    def extract(
+        self, *, text: str, fields: List[str], instructions: Optional[str] = None
+    ) -> Dict[str, Any]:
+        """Pull a caller-defined set of fields out of any text."""
+        return self._post("/v1/extract", {"text": text, "fields": fields, "instructions": instructions})
+
+    def classify(
+        self,
+        *,
+        text: str,
+        labels: List[str],
+        multi: Optional[bool] = None,
+        instructions: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """Classify text against your own taxonomy."""
+        return self._post(
+            "/v1/classify",
+            {"text": text, "labels": labels, "multi": multi, "instructions": instructions},
+        )
+
+    def summarize(
+        self,
+        *,
+        text: str,
+        length: Optional[str] = None,
+        action_items: Optional[bool] = None,
+    ) -> Dict[str, Any]:
+        """Summarize long text into a summary, key points, and action items."""
+        return self._post(
+            "/v1/summarize", {"text": text, "length": length, "actionItems": action_items}
+        )
+
+    def redact(
+        self,
+        *,
+        text: str,
+        types: Optional[List[str]] = None,
+        placeholder: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """Detect and strip PII/PHI from text."""
+        return self._post("/v1/redact", {"text": text, "types": types, "placeholder": placeholder})
+
+    def sentiment(self, *, text: str, aspects: Optional[List[str]] = None) -> Dict[str, Any]:
+        """Sentiment, aspects, and themes from feedback text."""
+        return self._post("/v1/sentiment", {"text": text, "aspects": aspects})
+
+    def contract(
+        self,
+        *,
+        file_url: Optional[str] = None,
+        text: Optional[str] = None,
+        file: Optional[Dict[str, str]] = None,
+    ) -> Dict[str, Any]:
+        """Analyze a contract into parties, terms, obligations, and risk flags."""
+        return self._post("/v1/contract", _document(file_url, text, file))
+
+    def chargeback(
+        self,
+        *,
+        reason: str,
+        transaction: Dict[str, Any],
+        evidence: Optional[List[str]] = None,
+        context: Optional[str] = None,
+        network: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """Turn dispute details into a chargeback representment packet."""
+        return self._post(
+            "/v1/chargeback",
+            {
+                "reason": reason,
+                "transaction": transaction,
+                "evidence": evidence,
+                "context": context,
+                "network": network,
+            },
+        )
+
+    def enrich(
+        self, *, domain: Optional[str] = None, email: Optional[str] = None
+    ) -> Dict[str, Any]:
+        """Enrich a domain or work email into a structured company profile."""
+        if not domain and not email:
+            raise ValueError("Provide one of: domain or email.")
+        return self._post("/v1/enrich", {"domain": domain, "email": email})
+
+    def account(self) -> Dict[str, Any]:
+        """Fetch the authenticated account's credit balance."""
+        return self._request("GET", "/v1/account")

kynth-0.1.0.dist-info/METADATA

@@ -0,0 +1,71 @@
+Metadata-Version: 2.4
+Name: kynth
+Version: 0.1.0
+Summary: Official Python SDK for Kynth Core — the AI back-end for your product.
+Project-URL: Homepage, https://api.kynth.studio
+Project-URL: Documentation, https://api.kynth.studio/docs
+Project-URL: Source, https://github.com/kyisaiah47/kynth-os
+Author: Kynth Studios
+License: MIT
+Keywords: ai,api,chargeback,contract,document-parsing,kynth,llm,ocr,pii
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# kynth
+
+Official Python SDK for **[Kynth Core](https://api.kynth.studio)** — the AI back-end for your product. Parse documents, extract fields, redact PII, analyze contracts, fight chargebacks, and enrich companies.
+
+```bash
+pip install kynth
+```
+
+## Quickstart
+
+```python
+from kynth import Kynth
+
+client = Kynth(api_key="ksk_live_...")
+
+doc = client.parse(file_url="https://.../invoice.pdf")
+print(doc["totalAmount"])              # 4820.5
+print(doc["usage"]["balanceRemaining"])  # 490
+```
+
+Get a key (and 500 free credits) at **[api.kynth.studio](https://api.kynth.studio)**. Zero dependencies — stdlib only, Python 3.8+.
+
+## Methods
+
+Every method returns the endpoint result as a dict, including a `usage` envelope. A non-2xx response raises a typed `KynthError` (and never burns credits).
+
+```python
+client.parse(file_url=...)                                  # documents → JSON
+client.extract(text=..., fields=["order", "total"])         # pull named fields
+client.classify(text=..., labels=["billing", "tech"])       # label text
+client.summarize(text=..., length="standard")               # summary + actions
+client.redact(text=...)                                      # strip PII/PHI
+client.sentiment(text=..., aspects=["product"])             # sentiment + aspects
+client.contract(file_url=...)                               # contract → terms + risks
+client.chargeback(reason=..., transaction={"amount": 129})  # representment packet
+client.enrich(email="sam@stripe.com")                       # company profile
+client.account()                                            # balance
+```
+
+## Error handling
+
+```python
+from kynth import Kynth, KynthError
+
+client = Kynth(api_key="ksk_live_...")
+try:
+    client.parse(file_url="https://.../invoice.pdf")
+except KynthError as err:
+    # err.code: "insufficient_credits" | "rate_limited" | "unauthorized" | ...
+    print(err.code, err.status, err.message)
+```
+
+MIT © Kynth Studios

kynth-0.1.0.dist-info/RECORD

@@ -0,0 +1,4 @@
+kynth/__init__.py,sha256=fDTzqVrAgnyuopKB1yFdwOkxrsHC6ZuClMQX3GoGm3E,7349
+kynth-0.1.0.dist-info/METADATA,sha256=38tfVajz_Uyp6ytdCLf9V-IgzFq0Y-zrpv1r5Y4KEqE,2674
+kynth-0.1.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+kynth-0.1.0.dist-info/RECORD,,

kynth-0.1.0.dist-info/WHEEL

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