autoicd 0.2.0__py3-none-any.whl

autoicd/__init__.py

@@ -0,0 +1,50 @@
+"""AutoICD API — Python SDK.
+
+Official Python SDK for the AutoICD API: clinical text to ICD-10-CM diagnosis codes.
+"""
+
+from .client import AutoICD
+from .errors import (
+    AuthenticationError,
+    AutoICDError,
+    NotFoundError,
+    RateLimit,
+    RateLimitError,
+)
+from .types import (
+    AnonymizeResponse,
+    ChapterInfo,
+    CodeDetail,
+    CodeDetailFull,
+    CodeMatch,
+    CodeOptions,
+    CodeSearchResponse,
+    CodeTermInfo,
+    CodingEntity,
+    CodingResponse,
+    PIIEntity,
+    SearchOptions,
+)
+
+__all__ = [
+    "AutoICD",
+    # Errors
+    "AutoICDError",
+    "AuthenticationError",
+    "RateLimitError",
+    "NotFoundError",
+    # Types
+    "CodeOptions",
+    "CodeMatch",
+    "CodingEntity",
+    "CodingResponse",
+    "SearchOptions",
+    "CodeDetail",
+    "CodeDetailFull",
+    "ChapterInfo",
+    "CodeSearchResponse",
+    "CodeTermInfo",
+    "PIIEntity",
+    "AnonymizeResponse",
+    "RateLimit",
+]

autoicd/client.py

@@ -0,0 +1,277 @@
+from __future__ import annotations
+
+from datetime import datetime, timezone
+from typing import Any
+from urllib.parse import quote, urlencode
+
+import httpx
+
+from .errors import (
+    AuthenticationError,
+    AutoICDError,
+    NotFoundError,
+    RateLimit,
+    RateLimitError,
+)
+from .types import (
+    AnonymizeResponse,
+    ChapterInfo,
+    CodeDetail,
+    CodeDetailFull,
+    CodeMatch,
+    CodeOptions,
+    CodeSearchResponse,
+    CodeTermInfo,
+    CodingEntity,
+    CodingResponse,
+    PIIEntity,
+    SearchOptions,
+)
+
+_DEFAULT_BASE_URL = "https://autoicdapi.com"
+_DEFAULT_TIMEOUT = 30.0
+
+
+class Codes:
+    """Sub-resource for ICD-10-CM code lookups."""
+
+    def __init__(self, client: AutoICD) -> None:
+        self._client = client
+
+    def search(
+        self, query: str, options: SearchOptions | None = None
+    ) -> CodeSearchResponse:
+        """Search ICD-10-CM codes by description."""
+        params: dict[str, str] = {"q": query}
+        if options:
+            if options.limit is not None:
+                params["limit"] = str(options.limit)
+            if options.offset is not None:
+                params["offset"] = str(options.offset)
+        data = self._client._get(f"/api/v1/codes/search?{urlencode(params)}")
+        return CodeSearchResponse(
+            query=data["query"],
+            count=data["count"],
+            codes=[CodeDetail(**c) for c in data["codes"]],
+        )
+
+    def get(self, code: str) -> CodeDetailFull:
+        """Get full details for an ICD-10-CM code.
+
+        Returns comprehensive info including synonyms (SNOMED CT, UMLS),
+        hierarchy (parent/children), and chapter/block classification.
+        """
+        data = self._client._get(f"/api/v1/codes/{quote(code, safe='')}")
+        return _parse_code_detail_full(data)
+
+    def terms(self, code: str) -> list[CodeTermInfo]:
+        """Get indexed terms and synonyms for an ICD-10-CM code."""
+        data = self._client._get(f"/api/v1/codes/{quote(code, safe='')}/terms")
+        return [CodeTermInfo(**t) for t in data]
+
+
+class AutoICD:
+    """Client for the AutoICD API.
+
+    Args:
+        api_key: Your API key (starts with ``sk_``).
+        base_url: API base URL (default ``https://autoicdapi.com``).
+        timeout: Request timeout in seconds (default 30).
+        http_client: Optional ``httpx.Client`` instance for custom configuration.
+    """
+
+    def __init__(
+        self,
+        *,
+        api_key: str,
+        base_url: str = _DEFAULT_BASE_URL,
+        timeout: float = _DEFAULT_TIMEOUT,
+        http_client: httpx.Client | None = None,
+    ) -> None:
+        if not api_key:
+            raise ValueError("api_key must be a non-empty string")
+
+        self._api_key = api_key
+        self._base_url = base_url.rstrip("/")
+        self._timeout = timeout
+        self._owns_client = http_client is None
+        self._http = http_client or httpx.Client(timeout=self._timeout)
+        self.codes = Codes(self)
+        self.last_rate_limit: RateLimit | None = None
+
+    def close(self) -> None:
+        """Close the underlying HTTP client (only if we created it)."""
+        if self._owns_client:
+            self._http.close()
+
+    def __enter__(self) -> AutoICD:
+        return self
+
+    def __exit__(self, *_: Any) -> None:
+        self.close()
+
+    # ── Public methods ──────────────────────────────────────────────
+
+    def code(
+        self, text: str, options: CodeOptions | None = None
+    ) -> CodingResponse:
+        """Code clinical text to ICD-10-CM diagnoses.
+
+        Args:
+            text: Clinical note or free-text input.
+            options: Optional coding parameters.
+        """
+        body: dict[str, Any] = {"text": text}
+        if options:
+            if options.top_k is not None:
+                body["top_k"] = options.top_k
+            if options.include_negated is not None:
+                body["include_negated"] = options.include_negated
+            if options.strategy is not None:
+                body["strategy"] = options.strategy
+        data = self._post("/api/v1/code", body)
+        return _parse_coding_response(data)
+
+    def anonymize(self, text: str) -> AnonymizeResponse:
+        """De-identify PHI/PII in clinical text.
+
+        Args:
+            text: Clinical note containing PHI.
+        """
+        data = self._post("/api/v1/anonymize", {"text": text})
+        return AnonymizeResponse(
+            original_text=data["original_text"],
+            anonymized_text=data["anonymized_text"],
+            pii_count=data["pii_count"],
+            pii_entities=[PIIEntity(**e) for e in data["pii_entities"]],
+        )
+
+    # ── HTTP internals ──────────────────────────────────────────────
+
+    def _get(self, path: str) -> Any:
+        return self._request("GET", path)
+
+    def _post(self, path: str, body: dict[str, Any]) -> Any:
+        return self._request("POST", path, body=body)
+
+    def _request(
+        self,
+        method: str,
+        path: str,
+        body: dict[str, Any] | None = None,
+    ) -> Any:
+        url = f"{self._base_url}{path}"
+        headers = {
+            "Authorization": f"Bearer {self._api_key}",
+            "Content-Type": "application/json",
+            "Accept": "application/json",
+        }
+
+        response = self._http.request(
+            method,
+            url,
+            headers=headers,
+            json=body,
+            timeout=self._timeout,
+        )
+
+        # Parse rate limit headers
+        self._parse_rate_limit(response.headers)
+
+        # Success
+        if 200 <= response.status_code < 300:
+            return response.json()
+
+        # Error handling
+        try:
+            error_body = response.json()
+            message = error_body.get("error", response.text)
+        except Exception:
+            message = response.text
+
+        if response.status_code == 401:
+            raise AuthenticationError(message)
+        if response.status_code == 404:
+            raise NotFoundError(message)
+        if response.status_code == 429:
+            rl = self.last_rate_limit or RateLimit(
+                limit=0, remaining=0, reset_at=datetime.now(timezone.utc)
+            )
+            raise RateLimitError(message, rate_limit=rl)
+
+        raise AutoICDError(response.status_code, message)
+
+    def _parse_rate_limit(self, headers: httpx.Headers) -> None:
+        limit = headers.get("X-RateLimit-Limit")
+        remaining = headers.get("X-RateLimit-Remaining")
+        reset_at = headers.get("X-RateLimit-Reset")
+
+        if limit is not None and remaining is not None and reset_at is not None:
+            self.last_rate_limit = RateLimit(
+                limit=int(limit),
+                remaining=int(remaining),
+                reset_at=datetime.fromisoformat(reset_at),
+            )
+        else:
+            self.last_rate_limit = None
+
+
+# ── Response parsing helpers ────────────────────────────────────────
+
+
+def _parse_code_match(data: dict[str, Any]) -> CodeMatch:
+    return CodeMatch(
+        code=data["code"],
+        description=data["description"],
+        similarity=data["similarity"],
+        confidence=data["confidence"],
+        matched_term=data["matched_term"],
+    )
+
+
+def _parse_entity(data: dict[str, Any]) -> CodingEntity:
+    return CodingEntity(
+        entity_text=data["entity_text"],
+        entity_start=data["entity_start"],
+        entity_end=data["entity_end"],
+        negated=data["negated"],
+        historical=data["historical"],
+        family_history=data["family_history"],
+        uncertain=data["uncertain"],
+        severity=data.get("severity"),
+        codes=[_parse_code_match(c) for c in data.get("codes", [])],
+        merged_from=data.get("merged_from"),
+        corrected_from=data.get("corrected_from"),
+    )
+
+
+def _parse_coding_response(data: dict[str, Any]) -> CodingResponse:
+    return CodingResponse(
+        text=data["text"],
+        provider=data["provider"],
+        strategy=data["strategy"],
+        entity_count=data["entity_count"],
+        entities=[_parse_entity(e) for e in data.get("entities", [])],
+    )
+
+
+def _parse_code_detail_full(data: dict[str, Any]) -> CodeDetailFull:
+    parent_data = data.get("parent")
+    parent = CodeDetail(**parent_data) if parent_data else None
+
+    children = [CodeDetail(**c) for c in data.get("children", [])]
+
+    chapter_data = data.get("chapter")
+    chapter = ChapterInfo(**chapter_data) if chapter_data else None
+
+    return CodeDetailFull(
+        code=data["code"],
+        short_description=data["short_description"],
+        long_description=data["long_description"],
+        is_billable=data["is_billable"],
+        synonyms=data.get("synonyms", {}),
+        parent=parent,
+        children=children,
+        chapter=chapter,
+        block=data.get("block"),
+    )

autoicd/errors.py

@@ -0,0 +1,43 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import datetime
+
+
+@dataclass
+class RateLimit:
+    """Rate limit info from API response headers."""
+
+    limit: int
+    remaining: int
+    reset_at: datetime
+
+
+class AutoICDError(Exception):
+    """Base exception for AutoICD API errors."""
+
+    def __init__(self, status: int, message: str) -> None:
+        self.status = status
+        super().__init__(message)
+
+
+class AuthenticationError(AutoICDError):
+    """Raised when the API key is invalid or revoked (401)."""
+
+    def __init__(self, message: str = "Invalid API key") -> None:
+        super().__init__(401, message)
+
+
+class RateLimitError(AutoICDError):
+    """Raised when the request limit is exceeded (429)."""
+
+    def __init__(self, message: str, rate_limit: RateLimit) -> None:
+        self.rate_limit = rate_limit
+        super().__init__(429, message)
+
+
+class NotFoundError(AutoICDError):
+    """Raised when a resource is not found (404)."""
+
+    def __init__(self, message: str = "Resource not found") -> None:
+        super().__init__(404, message)

autoicd/types.py

@@ -0,0 +1,210 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Literal
+
+
+# ── Coding ──────────────────────────────────────────────────────────
+
+
+@dataclass
+class CodeOptions:
+    """Options for the ``code()`` method."""
+
+    top_k: int | None = None
+    """Number of ICD-10 candidates per entity (1-25, default 5)."""
+
+    include_negated: bool | None = None
+    """Include negated conditions in results (default True)."""
+
+    strategy: Literal["individual", "merged"] | None = None
+    """Entity extraction strategy (default "individual")."""
+
+
+@dataclass
+class CodeMatch:
+    """A single ranked ICD-10 candidate."""
+
+    code: str
+    """ICD-10-CM code (e.g. ``"E11.21"``)."""
+
+    description: str
+    """Official code description."""
+
+    similarity: float
+    """0-1 cosine similarity score."""
+
+    confidence: Literal["high", "moderate"]
+    """Confidence level."""
+
+    matched_term: str
+    """The index term that produced this match."""
+
+
+@dataclass
+class CodingEntity:
+    """An extracted diagnosis entity with ICD-10 candidates."""
+
+    entity_text: str
+    """Extracted text span."""
+
+    entity_start: int
+    """Character offset start."""
+
+    entity_end: int
+    """Character offset end."""
+
+    negated: bool
+    """Whether the condition was negated."""
+
+    historical: bool
+    """Whether this is historical/resolved."""
+
+    family_history: bool
+    """Whether this is a family member's condition."""
+
+    uncertain: bool
+    """Whether the entity is hedged/uncertain."""
+
+    severity: str | None
+    """Severity qualifier (e.g. ``"severe"``)."""
+
+    codes: list[CodeMatch] = field(default_factory=list)
+    """Ranked ICD-10 candidates."""
+
+    merged_from: list[str] | None = None
+    """Source texts if merged."""
+
+    corrected_from: str | None = None
+    """Original text before spell correction."""
+
+
+@dataclass
+class CodingResponse:
+    """Complete coding result."""
+
+    text: str
+    """Input text that was processed."""
+
+    provider: str
+    """AI provider used for code matching."""
+
+    strategy: str
+    """Strategy used."""
+
+    entity_count: int
+    """Total number of entities."""
+
+    entities: list[CodingEntity] = field(default_factory=list)
+    """Extracted entities sorted by position."""
+
+
+# ── Code Search ─────────────────────────────────────────────────────
+
+
+@dataclass
+class SearchOptions:
+    """Options for ``codes.search()``."""
+
+    limit: int | None = None
+    """1-100 results per page (default 20)."""
+
+    offset: int | None = None
+    """Pagination offset (default 0)."""
+
+
+@dataclass
+class CodeDetail:
+    """Basic details for an ICD-10-CM code."""
+
+    code: str
+    short_description: str
+    long_description: str
+    is_billable: bool
+
+
+@dataclass
+class ChapterInfo:
+    """ICD-10-CM chapter classification."""
+
+    number: int
+    """Chapter number (1-22)."""
+
+    range: str
+    """Code range (e.g. ``"E00-E89"``)."""
+
+    title: str
+    """Chapter title."""
+
+
+@dataclass
+class CodeDetailFull(CodeDetail):
+    """Comprehensive details for an ICD-10-CM code including hierarchy and synonyms."""
+
+    synonyms: dict[str, list[str]] = field(default_factory=dict)
+    """Synonyms grouped by source: ``"snomed"``, ``"umls"``, ``"icd10_augmented"``."""
+
+    parent: CodeDetail | None = None
+    """Parent code in the ICD-10 hierarchy, or ``None`` for top-level categories."""
+
+    children: list[CodeDetail] = field(default_factory=list)
+    """Direct child codes in the ICD-10 hierarchy."""
+
+    chapter: ChapterInfo | None = None
+    """ICD-10-CM chapter this code belongs to."""
+
+    block: str | None = None
+    """Code block range (e.g. ``"E08-E13"``)."""
+
+
+@dataclass
+class CodeSearchResponse:
+    """Search results for ICD-10-CM codes."""
+
+    query: str
+    count: int
+    codes: list[CodeDetail] = field(default_factory=list)
+
+
+@dataclass
+class CodeTermInfo:
+    """An indexed term for an ICD-10-CM code."""
+
+    term: str
+    """The term text."""
+
+    term_type: str
+    """Term type (e.g. ``"long_desc"``, ``"synonym"``)."""
+
+
+# ── Anonymization ───────────────────────────────────────────────────
+
+
+@dataclass
+class PIIEntity:
+    """A detected PII entity."""
+
+    text: str
+    """Original PII text."""
+
+    start: int
+    """Character offset start."""
+
+    end: int
+    """Character offset end."""
+
+    label: str
+    """PII type: NAME, DATE, SSN, PHONE, EMAIL, ADDRESS, MRN, AGE."""
+
+    replacement: str
+    """Replacement placeholder (e.g. ``"[NAME]"``)."""
+
+
+@dataclass
+class AnonymizeResponse:
+    """Result of PHI de-identification."""
+
+    original_text: str
+    anonymized_text: str
+    pii_count: int
+    pii_entities: list[PIIEntity] = field(default_factory=list)

autoicd-0.2.0.dist-info/METADATA

@@ -0,0 +1,307 @@
+Metadata-Version: 2.4
+Name: autoicd
+Version: 0.2.0
+Summary: Official Python SDK for the AutoICD API — clinical text to ICD-10-CM diagnosis codes, powered by AI and medical NLP
+Project-URL: Homepage, https://autoicdapi.com
+Project-URL: Documentation, https://autoicdapi.com/docs
+Project-URL: Repository, https://github.com/fcggamou/autoicd-python
+Project-URL: Issues, https://github.com/fcggamou/autoicd-python/issues
+Author-email: AutoICD <info@autoicdapi.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: autoicd,clinical-decision-support,clinical-nlp,diagnosis-codes,ehr,emr,health-tech,hipaa,icd-10,icd-10-cm,medical-billing,medical-coding,medical-nlp,phi-deidentification,revenue-cycle-management
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Healthcare Industry
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Medical Science Apps.
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Requires-Dist: httpx>=0.27
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: ruff>=0.5; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# AutoICD API — Python SDK
+
+[![PyPI version](https://img.shields.io/pypi/v/autoicd.svg)](https://pypi.org/project/autoicd/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
+[![Python](https://img.shields.io/badge/Python-3.10+-blue.svg)](https://www.python.org/)
+
+Official Python SDK for the [AutoICD API](https://autoicdapi.com) — clinical text to ICD-10-CM diagnosis codes, powered by AI and medical NLP.
+
+Single dependency (`httpx`). Works in **Python 3.10+**.
+
+> Built for EHR integrations, health-tech platforms, medical billing, clinical decision support, and revenue cycle management.
+
+---
+
+## Why AutoICD API
+
+| | |
+|---|---|
+| **AI-Powered ICD-10 Coding** | Clinical NLP extracts diagnoses from free-text notes and maps them to ICD-10-CM codes — no manual lookup required |
+| **74,000+ ICD-10-CM Codes** | Full 2025 code set enriched with SNOMED CT synonyms for comprehensive matching |
+| **Negation & Context Detection** | Knows the difference between "patient has diabetes" and "patient denies diabetes" — flags negated, historical, uncertain, and family-history mentions |
+| **PHI De-identification** | HIPAA-compliant anonymization of names, dates, SSNs, phone numbers, emails, addresses, MRNs, and ages |
+| **Confidence Scoring** | Every code match includes a similarity score and confidence level so you can set your own acceptance thresholds |
+| **Spell Correction** | Handles misspellings in clinical text — "diabeties" still maps to the right code |
+| **Fully Typed** | Complete type annotations for all requests and responses |
+
+---
+
+## Install
+
+```bash
+pip install autoicd
+```
+
+<details>
+<summary>uv / poetry / pdm</summary>
+
+```bash
+uv add autoicd
+poetry add autoicd
+pdm add autoicd
+```
+
+</details>
+
+---
+
+## Quick Start
+
+```python
+from autoicd import AutoICD
+
+client = AutoICD(api_key="sk_...")
+
+result = client.code(
+    "Patient has type 2 diabetes and essential hypertension"
+)
+
+for entity in result.entities:
+    print(entity.entity_text, "→", entity.codes[0].code)
+# "type 2 diabetes"       → "E11.9"
+# "essential hypertension" → "I10"
+```
+
+---
+
+## Features
+
+### Automated ICD-10 Medical Coding
+
+Extract diagnosis entities from clinical notes and map them to ICD-10-CM codes. Each entity includes ranked candidates with confidence scores, negation status, and context flags.
+
+```python
+result = client.code(
+    "History of severe COPD with acute exacerbation. Patient denies chest pain."
+)
+
+for entity in result.entities:
+    print(entity.entity_text)
+    print(f"  Negated: {entity.negated}")
+    print(f"  Historical: {entity.historical}")
+    for match in entity.codes:
+        print(
+            f"  {match.code} — {match.description} "
+            f"({match.confidence}, {match.similarity * 100:.1f}%)"
+        )
+```
+
+Fine-tune results with coding options:
+
+```python
+from autoicd import CodeOptions
+
+result = client.code(
+    "Patient presents with acute bronchitis and chest pain",
+    options=CodeOptions(
+        top_k=3,               # Top 3 ICD-10 candidates per entity (default: 5)
+        strategy="merged",     # "individual" or "merged" entity strategy
+        include_negated=False, # Exclude negated conditions from results
+    ),
+)
+```
+
+### ICD-10 Code Search
+
+Search the full ICD-10-CM 2025 code set by description. Perfect for building code lookup UIs, autocomplete fields, and validation workflows.
+
+```python
+results = client.codes.search("diabetes mellitus")
+# results.codes → [CodeDetail(code="E11.9", short_description="...", ...), ...]
+
+from autoicd import SearchOptions
+results = client.codes.search("heart failure", options=SearchOptions(limit=5))
+```
+
+### ICD-10 Code Details
+
+Get full details for any ICD-10-CM code — descriptions, billable status, and indexed terms.
+
+```python
+detail = client.codes.get("E11.9")
+print(detail.code)              # "E11.9"
+print(detail.long_description)  # "Type 2 diabetes mellitus without complications"
+print(detail.is_billable)       # True
+```
+
+### ICD-10 Code Terms & Synonyms
+
+Retrieve all indexed terms and synonyms for a code — includes SNOMED CT mappings and clinical variants.
+
+```python
+terms = client.codes.terms("E11.9")
+for t in terms:
+    print(t.term, f"({t.term_type})")
+# "Type 2 diabetes mellitus without complications" (long_desc)
+# "adult onset diabetes" (synonym)
+# ...
+```
+
+### PHI De-identification
+
+Strip protected health information from clinical notes before storage or analysis. HIPAA-compliant de-identification for names, dates, SSNs, phone numbers, emails, addresses, MRNs, and ages.
+
+```python
+result = client.anonymize(
+    "John Smith, DOB 01/15/1980, MRN 123456, has COPD"
+)
+
+print(result.anonymized_text)
+# "[NAME], DOB [DATE], MRN [MRN], has COPD"
+
+print(result.pii_count)     # 3
+print(result.pii_entities)  # [PIIEntity(text="John Smith", label="NAME", ...), ...]
+```
+
+---
+
+## Use Cases
+
+- **EHR / EMR Integration** — Auto-code clinical notes as providers type, reducing manual coding burden
+- **Medical Billing & RCM** — Accelerate claim submission with accurate ICD-10 codes
+- **Clinical Decision Support** — Map patient conditions to standardized codes for analytics and alerts
+- **Health-Tech SaaS** — Add ICD-10 coding to your platform without building ML infrastructure
+- **Clinical Research** — Extract and standardize diagnoses from unstructured medical records
+- **Insurance & Payer Systems** — Validate and suggest diagnosis codes during claims processing
+- **Telehealth Platforms** — Generate diagnosis codes from visit notes and transcriptions
+
+---
+
+## Error Handling
+
+```python
+from autoicd import (
+    AutoICD,
+    AuthenticationError,
+    RateLimitError,
+    NotFoundError,
+)
+
+try:
+    result = client.code("...")
+except AuthenticationError:
+    # Invalid or revoked API key (401)
+    ...
+except RateLimitError as e:
+    # Request limit exceeded (429)
+    print(e.rate_limit.remaining, e.rate_limit.reset_at)
+except NotFoundError:
+    # ICD-10 code not found (404)
+    ...
+```
+
+Rate limit info is available after every request:
+
+```python
+client.code("...")
+print(client.last_rate_limit)
+# RateLimit(limit=1000, remaining=987, reset_at=datetime(...))
+```
+
+---
+
+## Configuration
+
+```python
+client = AutoICD(
+    api_key="sk_...",                   # Required — get yours at https://autoicdapi.com
+    base_url="https://...",             # Default: https://autoicdapi.com
+    timeout=60.0,                       # Default: 30.0 seconds
+    http_client=httpx.Client(...),      # Custom httpx client (for proxies, mTLS, etc.)
+)
+```
+
+Use as a context manager for automatic cleanup:
+
+```python
+with AutoICD(api_key="sk_...") as client:
+    result = client.code("Patient has diabetes")
+```
+
+---
+
+## API Reference
+
+Full REST API documentation at [autoicdapi.com/docs](https://autoicdapi.com/docs).
+
+| Method | Description |
+|--------|-------------|
+| `client.code(text, options?)` | Code clinical text to ICD-10-CM diagnoses |
+| `client.anonymize(text)` | De-identify PHI/PII in clinical text |
+| `client.codes.search(query, options?)` | Search ICD-10-CM codes by description |
+| `client.codes.get(code)` | Get details for an ICD-10-CM code |
+| `client.codes.terms(code)` | Get indexed terms/synonyms for a code |
+
+---
+
+## Types
+
+All request and response types are exported:
+
+```python
+from autoicd import (
+    CodingResponse,
+    CodingEntity,
+    CodeMatch,
+    CodeOptions,
+    CodeDetail,
+    CodeSearchResponse,
+    CodeTermInfo,
+    AnonymizeResponse,
+    PIIEntity,
+    RateLimit,
+    SearchOptions,
+)
+```
+
+---
+
+## Requirements
+
+- **Python 3.10+**
+- An API key from [autoicdapi.com](https://autoicdapi.com)
+
+---
+
+## Links
+
+- [AutoICD API](https://autoicdapi.com) — Homepage and API key management
+- [API Documentation](https://autoicdapi.com/docs) — Full REST API reference
+- [TypeScript SDK](https://www.npmjs.com/package/autoicd) — `npm install autoicd`
+- [ICD-10-CM 2025 Code Set](https://www.cms.gov/medicare/coding-billing/icd-10-codes) — Official CMS reference
+
+---
+
+## License
+
+MIT

autoicd-0.2.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+autoicd/__init__.py,sha256=ip3RVonlUsVkD-DAHT8cp9uSahsMBpdgnhk6CmoRBkM,924
+autoicd/client.py,sha256=aCV7cPOGQUjJTIEdu7jLLOBoRIYHh28gWFBHagXB4YE,9013
+autoicd/errors.py,sha256=ivpEuy_SkTbagS4fnAd2nCdWN_sWuOAuFk4S0sRD__0,1100
+autoicd/types.py,sha256=fhjVc2Oy7Rqmssbf59I5QgcxwbzgPTRmu-cjTDnevjM,5018
+autoicd-0.2.0.dist-info/METADATA,sha256=JHnk21XJvAirId0ynFoSzPL_M2E_3sm3-f5w37ylv7Q,9490
+autoicd-0.2.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+autoicd-0.2.0.dist-info/licenses/LICENSE,sha256=IYkACTgDzY__lf7SsIcjrjOtil429XVYegIOrZ_9Su8,1061
+autoicd-0.2.0.dist-info/RECORD,,

autoicd-0.2.0.dist-info/WHEEL

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

autoicd-0.2.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Fede
+
+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.