infratex 0.1.0__py3-none-any.whl

infratex/__init__.py

@@ -0,0 +1,35 @@
+"""Infratex Python SDK."""
+
+from ._client import Infratex
+from ._http import InfratexError
+from ._types import (
+    Account,
+    BillingSummary,
+    Collection,
+    Conversation,
+    Document,
+    DocumentList,
+    Index,
+    SearchResponse,
+    SearchResult,
+    StreamEvent,
+    UploadedDocument,
+)
+
+__all__ = [
+    "Infratex",
+    "InfratexError",
+    "Account",
+    "BillingSummary",
+    "Collection",
+    "Conversation",
+    "Document",
+    "DocumentList",
+    "Index",
+    "SearchResponse",
+    "SearchResult",
+    "StreamEvent",
+    "UploadedDocument",
+]
+
+__version__ = "0.1.0"

infratex/_client.py

@@ -0,0 +1,84 @@
+"""Main Infratex client."""
+
+from __future__ import annotations
+
+import os
+from typing import Optional
+
+import httpx
+
+from ._http import HTTPClient
+from .resources.documents import Documents
+from .resources.searches import Searches
+from .resources.responses import Responses
+from .resources.collections import Collections
+from .resources.conversations import Conversations
+from .resources.account import AccountResource
+from .resources.billing import Billing
+
+__all__ = ["Infratex"]
+
+
+class Infratex:
+    """Infratex API client.
+
+    Parameters
+    ----------
+    api_key:
+        Your Infratex API key (``infratex_sk_...``).  Falls back to the
+        ``INFRATEX_API_KEY`` environment variable when not provided.
+    base_url:
+        Override the API base URL (default ``https://api.infratex.io``).
+    timeout:
+        Request timeout in seconds (default 300).
+    httpx_client:
+        Optionally provide your own ``httpx.Client`` instance.
+    """
+
+    documents: Documents
+    searches: Searches
+    responses: Responses
+    collections: Collections
+    conversations: Conversations
+    account: AccountResource
+    billing: Billing
+
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        *,
+        base_url: Optional[str] = None,
+        timeout: Optional[float] = None,
+        httpx_client: Optional[httpx.Client] = None,
+    ) -> None:
+        resolved_key = api_key or os.environ.get("INFRATEX_API_KEY", "")
+        if not resolved_key:
+            raise ValueError(
+                "An API key is required. Pass api_key= or set the INFRATEX_API_KEY "
+                "environment variable."
+            )
+
+        self._http = HTTPClient(
+            api_key=resolved_key,
+            base_url=base_url,
+            timeout=timeout,
+            httpx_client=httpx_client,
+        )
+
+        self.documents = Documents(self._http)
+        self.searches = Searches(self._http)
+        self.responses = Responses(self._http)
+        self.collections = Collections(self._http)
+        self.conversations = Conversations(self._http)
+        self.account = AccountResource(self._http)
+        self.billing = Billing(self._http)
+
+    def close(self) -> None:
+        """Close the underlying HTTP connection pool."""
+        self._http.close()
+
+    def __enter__(self) -> Infratex:
+        return self
+
+    def __exit__(self, *args: object) -> None:
+        self.close()

infratex/_http.py

@@ -0,0 +1,184 @@
+"""Low-level HTTP transport for the Infratex SDK."""
+
+from __future__ import annotations
+
+import json
+from typing import Any, Dict, Iterator, Optional
+
+import httpx
+
+__all__ = ["HTTPClient", "InfratexError"]
+
+_DEFAULT_BASE_URL = "https://api.infratex.io"
+_DEFAULT_TIMEOUT = 300.0  # seconds
+
+
+class InfratexError(Exception):
+    """Raised when the Infratex API returns an error response."""
+
+    def __init__(
+        self,
+        message: str,
+        *,
+        status_code: int = 0,
+        code: Optional[str] = None,
+        details: Optional[Dict[str, Any]] = None,
+    ) -> None:
+        super().__init__(message)
+        self.status_code = status_code
+        self.code = code
+        self.details = details
+
+    def __repr__(self) -> str:
+        return "InfratexError(status_code={!r}, code={!r}, message={!r})".format(
+            self.status_code, self.code, str(self)
+        )
+
+
+class HTTPClient:
+    """Thin wrapper around ``httpx.Client`` with auth and error handling."""
+
+    def __init__(
+        self,
+        *,
+        api_key: str,
+        base_url: Optional[str] = None,
+        timeout: Optional[float] = None,
+        httpx_client: Optional[httpx.Client] = None,
+    ) -> None:
+        self._api_key = api_key
+        self._base_url = (base_url or _DEFAULT_BASE_URL).rstrip("/")
+
+        if httpx_client is not None:
+            self._client = httpx_client
+        else:
+            self._client = httpx.Client(
+                base_url=self._base_url,
+                timeout=timeout or _DEFAULT_TIMEOUT,
+                headers={
+                    "Authorization": "Bearer {}".format(api_key),
+                    "User-Agent": "infratex-python/0.1.0",
+                },
+            )
+
+    # --------------------------------------------------------------------- #
+    # Public helpers
+    # --------------------------------------------------------------------- #
+
+    def request(
+        self,
+        method: str,
+        path: str,
+        *,
+        json_body: Optional[Dict[str, Any]] = None,
+        data: Optional[Dict[str, Any]] = None,
+        files: Optional[Any] = None,
+        params: Optional[Dict[str, Any]] = None,
+    ) -> Any:
+        """Send an HTTP request and return the parsed JSON body."""
+        # Strip None values from params
+        if params:
+            params = {k: v for k, v in params.items() if v is not None}
+
+        response = self._client.request(
+            method,
+            path,
+            json=json_body,
+            data=data,
+            files=files,
+            params=params or None,
+        )
+        return self._handle_response(response)
+
+    def request_text(
+        self,
+        method: str,
+        path: str,
+        *,
+        params: Optional[Dict[str, Any]] = None,
+    ) -> str:
+        """Send an HTTP request and return the raw text body."""
+        if params:
+            params = {k: v for k, v in params.items() if v is not None}
+
+        response = self._client.request(method, path, params=params or None)
+
+        if response.status_code >= 400:
+            self._raise_for_status(response)
+
+        return response.text
+
+    def request_no_content(
+        self,
+        method: str,
+        path: str,
+    ) -> None:
+        """Send an HTTP request that returns 204 No Content."""
+        response = self._client.request(method, path)
+        if response.status_code >= 400:
+            self._raise_for_status(response)
+
+    def stream_sse(
+        self,
+        method: str,
+        path: str,
+        *,
+        json_body: Optional[Dict[str, Any]] = None,
+    ) -> Iterator[Dict[str, Any]]:
+        """Send an HTTP request and iterate over SSE ``data:`` lines."""
+        with self._client.stream(method, path, json=json_body) as response:
+            if response.status_code >= 400:
+                # Read the full body for the error message
+                response.read()
+                self._raise_for_status(response)
+
+            for line in response.iter_lines():
+                if not line.startswith("data: "):
+                    continue
+                payload = line[len("data: "):]
+                try:
+                    yield json.loads(payload)
+                except json.JSONDecodeError:
+                    continue
+
+    def close(self) -> None:
+        self._client.close()
+
+    # --------------------------------------------------------------------- #
+    # Internal
+    # --------------------------------------------------------------------- #
+
+    @staticmethod
+    def _handle_response(response: httpx.Response) -> Any:
+        if response.status_code >= 400:
+            HTTPClient._raise_for_status(response)
+
+        # 204 No Content
+        if response.status_code == 204 or not response.content:
+            return None
+
+        return response.json()
+
+    @staticmethod
+    def _raise_for_status(response: httpx.Response) -> None:
+        status_code = response.status_code
+        code = None
+        message = "API request failed"
+        details = None
+
+        try:
+            body = response.json()
+            if isinstance(body, dict):
+                # The API may return {"detail": "..."} or {"code": "...", "message": "..."}
+                message = body.get("message") or body.get("detail") or message
+                code = body.get("code")
+                details = body.get("details")
+        except Exception:
+            message = response.text or message
+
+        raise InfratexError(
+            message,
+            status_code=status_code,
+            code=code,
+            details=details,
+        )

infratex/_types.py

@@ -0,0 +1,195 @@
+"""Typed response objects returned by the Infratex SDK."""
+
+from __future__ import annotations
+
+from typing import Any, Dict, List, Optional
+
+
+class _Base:
+    """Lightweight base that populates attributes from a dict."""
+
+    def __init__(self, data: Dict[str, Any]) -> None:
+        self._data = data
+        for key, value in data.items():
+            setattr(self, key, value)
+
+    def __repr__(self) -> str:
+        name = type(self).__name__
+        fields = ", ".join(
+            "{}={!r}".format(k, v)
+            for k, v in self._data.items()
+            if not k.startswith("_")
+        )
+        return "{}({})".format(name, fields)
+
+    def __getitem__(self, key: str) -> Any:
+        return self._data[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self._data
+
+    def to_dict(self) -> Dict[str, Any]:
+        return dict(self._data)
+
+
+# ---------------------------------------------------------------------------
+# Documents
+# ---------------------------------------------------------------------------
+class Document(_Base):
+    id: str
+    filename: str
+    status: str
+    method: str
+    pipeline: Optional[str]
+    page_count: Optional[int]
+    processing_time_ms: Optional[int]
+    error_message: Optional[str]
+    markdown_size_bytes: Optional[int]
+    chunk_count: Optional[int]
+    index_method: Optional[str]
+    collection_id: Optional[str]
+    markdown: Optional[str]
+    upload_time: Optional[str]
+    extraction_pages: Optional[List[Dict[str, Any]]]
+
+
+class UploadedDocument(_Base):
+    id: str
+    status: str
+    method: str
+    filename: str
+    pipeline: Optional[str]
+    page_count: Optional[int]
+    markdown: Optional[str]
+    extraction_ms: int
+    collection_id: Optional[str]
+    extraction_pages: Optional[List[Dict[str, Any]]]
+
+
+class DocumentList(_Base):
+    documents: List[Document]
+    total: int
+
+    def __init__(self, data: Dict[str, Any]) -> None:
+        super().__init__(data)
+        self.documents = [Document(d) for d in data.get("documents", [])]
+
+    def __iter__(self):  # type: ignore
+        return iter(self.documents)
+
+    def __len__(self) -> int:
+        return len(self.documents)
+
+
+# ---------------------------------------------------------------------------
+# Indexes
+# ---------------------------------------------------------------------------
+class Index(_Base):
+    document_id: str
+    filename: str
+    method: str
+    status: str
+    node_count: int
+    chunk_count: int
+    has_ast: bool
+    has_description: bool
+    processing_ms: int
+
+
+# ---------------------------------------------------------------------------
+# Search
+# ---------------------------------------------------------------------------
+class SearchResult(_Base):
+    document_id: str
+    document_name: Optional[str]
+    score: float
+    content: str
+    title: str
+    summary: str
+    node_id: Optional[str]
+    chunk_index: Optional[int]
+    metadata: Optional[Dict[str, Any]]
+    source: str
+
+
+class SearchResponse(_Base):
+    method: str
+    query: str
+    results: List[SearchResult]
+
+    def __init__(self, data: Dict[str, Any]) -> None:
+        super().__init__(data)
+        self.results = [SearchResult(r) for r in data.get("results", [])]
+
+    def __iter__(self):  # type: ignore
+        return iter(self.results)
+
+    def __len__(self) -> int:
+        return len(self.results)
+
+
+# ---------------------------------------------------------------------------
+# Responses (SSE streaming)
+# ---------------------------------------------------------------------------
+class StreamEvent:
+    """A single event from the SSE response stream."""
+
+    __slots__ = ("type", "content")
+
+    def __init__(self, type: str, content: Any) -> None:
+        self.type = type
+        self.content = content
+
+    def __repr__(self) -> str:
+        return "StreamEvent(type={!r}, content={!r})".format(self.type, self.content)
+
+
+# ---------------------------------------------------------------------------
+# Collections
+# ---------------------------------------------------------------------------
+class Collection(_Base):
+    id: str
+    name: str
+    created_at: str
+
+
+# ---------------------------------------------------------------------------
+# Conversations
+# ---------------------------------------------------------------------------
+class Conversation(_Base):
+    id: str
+    title: str
+    created_at: str
+    updated_at: Optional[str]
+    messages: Optional[List[Dict[str, Any]]]
+
+
+# ---------------------------------------------------------------------------
+# Account & Billing
+# ---------------------------------------------------------------------------
+class Tenant(_Base):
+    id: str
+    name: str
+    email: Optional[str]
+    credit_balance_micros: int
+    is_admin: bool
+    is_frozen: bool
+    created_at: str
+
+
+class Account(_Base):
+    tenant: Tenant
+
+    def __init__(self, data: Dict[str, Any]) -> None:
+        super().__init__(data)
+        self.tenant = Tenant(data.get("tenant", {}))
+
+
+class BillingSummary(_Base):
+    balance_micros: int
+    recent_transactions: List[Dict[str, Any]]
+    recent_credit_transactions: List[Dict[str, Any]]
+    recent_usage: List[Dict[str, Any]]
+    spend_by_service: List[Dict[str, Any]]
+    daily_spend: List[Dict[str, Any]]
+    totals: Dict[str, Any]

infratex/resources/__init__.py

@@ -0,0 +1,17 @@
+from .documents import Documents
+from .searches import Searches
+from .responses import Responses
+from .collections import Collections
+from .conversations import Conversations
+from .account import AccountResource
+from .billing import Billing
+
+__all__ = [
+    "Documents",
+    "Searches",
+    "Responses",
+    "Collections",
+    "Conversations",
+    "AccountResource",
+    "Billing",
+]

infratex/resources/account.py

@@ -0,0 +1,22 @@
+"""Account resource."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from .._types import Account as AccountModel
+
+if TYPE_CHECKING:
+    from .._http import HTTPClient
+
+
+class AccountResource:
+    """Interact with the ``/api/v1/account`` endpoint."""
+
+    def __init__(self, client: HTTPClient) -> None:
+        self._client = client
+
+    def get(self) -> AccountModel:
+        """Retrieve the current account details."""
+        resp = self._client.request("GET", "/api/v1/account")
+        return AccountModel(resp)

infratex/resources/billing.py

@@ -0,0 +1,22 @@
+"""Billing resource."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from .._types import BillingSummary
+
+if TYPE_CHECKING:
+    from .._http import HTTPClient
+
+
+class Billing:
+    """Interact with the ``/api/v1/billing`` endpoint."""
+
+    def __init__(self, client: HTTPClient) -> None:
+        self._client = client
+
+    def get(self) -> BillingSummary:
+        """Retrieve the billing summary for the current account."""
+        resp = self._client.request("GET", "/api/v1/billing")
+        return BillingSummary(resp)

infratex/resources/collections.py

@@ -0,0 +1,47 @@
+"""Collections resource."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, List
+
+from .._types import Collection
+
+if TYPE_CHECKING:
+    from .._http import HTTPClient
+
+
+class Collections:
+    """Interact with the ``/api/v1/collections`` endpoints."""
+
+    def __init__(self, client: HTTPClient) -> None:
+        self._client = client
+
+    def create(self, *, name: str) -> Collection:
+        """Create a new collection."""
+        resp = self._client.request(
+            "POST", "/api/v1/collections", json_body={"name": name}
+        )
+        return Collection(resp)
+
+    def list(self) -> List[Collection]:
+        """List all collections."""
+        resp = self._client.request("GET", "/api/v1/collections")
+        return [Collection(c) for c in resp]
+
+    def get(self, collection_id: str) -> Collection:
+        """Retrieve a single collection by ID."""
+        resp = self._client.request("GET", "/api/v1/collections/{}".format(collection_id))
+        return Collection(resp)
+
+    def update(self, collection_id: str, *, name: str) -> Collection:
+        """Rename a collection."""
+        resp = self._client.request(
+            "PATCH",
+            "/api/v1/collections/{}".format(collection_id),
+            json_body={"name": name},
+        )
+        return Collection(resp)
+
+    def delete(self, collection_id: str) -> None:
+        """Delete a collection."""
+        self._client.request_no_content("DELETE", "/api/v1/collections/{}".format(collection_id))

infratex/resources/conversations.py

@@ -0,0 +1,52 @@
+"""Conversations resource."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, List, Optional
+
+from .._types import Conversation
+
+if TYPE_CHECKING:
+    from .._http import HTTPClient
+
+
+class Conversations:
+    """Interact with the ``/api/v1/conversations`` endpoints."""
+
+    def __init__(self, client: HTTPClient) -> None:
+        self._client = client
+
+    def create(self, *, title: str = "New Chat") -> Conversation:
+        """Create a new conversation thread."""
+        resp = self._client.request(
+            "POST", "/api/v1/conversations", json_body={"title": title}
+        )
+        return Conversation(resp)
+
+    def list(
+        self,
+        *,
+        limit: int = 50,
+        offset: int = 0,
+    ) -> List[Conversation]:
+        """List conversations.
+
+        Parameters
+        ----------
+        limit:
+            Maximum number of conversations to return (1--100).
+        offset:
+            Pagination offset.
+        """
+        params = {"limit": limit, "offset": offset}
+        resp = self._client.request("GET", "/api/v1/conversations", params=params)
+        return [Conversation(c) for c in resp]
+
+    def get(self, conversation_id: str) -> Conversation:
+        """Retrieve a conversation and its messages."""
+        resp = self._client.request("GET", "/api/v1/conversations/{}".format(conversation_id))
+        return Conversation(resp)
+
+    def delete(self, conversation_id: str) -> None:
+        """Delete a conversation."""
+        self._client.request_no_content("DELETE", "/api/v1/conversations/{}".format(conversation_id))

infratex/resources/documents.py

@@ -0,0 +1,123 @@
+"""Documents resource."""
+
+from __future__ import annotations
+
+import os
+from typing import TYPE_CHECKING, Any, Dict, List, Optional
+
+from .._types import DocumentList, Document, Index, UploadedDocument
+
+if TYPE_CHECKING:
+    from .._http import HTTPClient
+
+
+class Documents:
+    """Interact with the ``/api/v1/documents`` endpoints."""
+
+    def __init__(self, client: HTTPClient) -> None:
+        self._client = client
+
+    def upload(
+        self,
+        file_path: str,
+        *,
+        method: Optional[str] = None,
+        pipeline: Optional[str] = None,
+        collection_id: Optional[str] = None,
+    ) -> UploadedDocument:
+        """Upload and parse a PDF document.
+
+        Parameters
+        ----------
+        file_path:
+            Local path to the PDF file.
+        method:
+            Parsing method (``"standard"``, ``"cost-efficient"``, ``"experimental"``).
+        pipeline:
+            Optional sub-pipeline (``"traditional"``, ``"math"``).
+        collection_id:
+            Optional collection to assign the document to.
+        """
+        filename = os.path.basename(file_path)
+        with open(file_path, "rb") as f:
+            files = {"file": (filename, f, "application/pdf")}
+            data: Dict[str, Any] = {}
+            if method is not None:
+                data["method"] = method
+            if pipeline is not None:
+                data["pipeline"] = pipeline
+            if collection_id is not None:
+                data["collection_id"] = collection_id
+
+            resp = self._client.request(
+                "POST",
+                "/api/v1/documents",
+                data=data,
+                files=files,
+            )
+        return UploadedDocument(resp)
+
+    def list(
+        self,
+        *,
+        limit: int = 50,
+        offset: int = 0,
+        collection_id: Optional[str] = None,
+        status: Optional[str] = None,
+    ) -> DocumentList:
+        """List documents.
+
+        Parameters
+        ----------
+        limit:
+            Maximum number of documents to return.
+        offset:
+            Pagination offset.
+        collection_id:
+            Filter by collection.
+        status:
+            Filter by document status.
+        """
+        params: Dict[str, Any] = {
+            "limit": limit,
+            "offset": offset,
+            "collection_id": collection_id,
+            "status": status,
+        }
+        resp = self._client.request("GET", "/api/v1/documents", params=params)
+        return DocumentList(resp)
+
+    def get(self, document_id: str) -> Document:
+        """Retrieve a single document by ID."""
+        resp = self._client.request("GET", "/api/v1/documents/{}".format(document_id))
+        return Document(resp)
+
+    def markdown(self, document_id: str) -> str:
+        """Download the parsed markdown for a document."""
+        return self._client.request_text("GET", "/api/v1/documents/{}/markdown".format(document_id))
+
+    def delete(self, document_id: str) -> None:
+        """Delete a document."""
+        self._client.request_no_content("DELETE", "/api/v1/documents/{}".format(document_id))
+
+    def index(
+        self,
+        document_id: str,
+        *,
+        method: str = "vector",
+    ) -> Index:
+        """Create a search index for a document.
+
+        Parameters
+        ----------
+        document_id:
+            The document to index.
+        method:
+            Indexing strategy: ``"vector"`` or ``"hybrid"``.
+        """
+        resp = self._client.request(
+            "POST",
+            "/api/v1/documents/{}/indexes".format(document_id),
+            json_body={"method": method},
+        )
+        return Index(resp)

infratex/resources/responses.py

@@ -0,0 +1,69 @@
+"""Responses resource (streaming AI answers)."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Dict, Iterator, List, Optional
+
+from .._types import StreamEvent
+
+if TYPE_CHECKING:
+    from .._http import HTTPClient
+
+
+class Responses:
+    """Interact with the ``/api/v1/responses`` endpoint."""
+
+    def __init__(self, client: HTTPClient) -> None:
+        self._client = client
+
+    def create(
+        self,
+        *,
+        message: str,
+        method: str = "vector",
+        limit: int = 5,
+        document_ids: Optional[List[str]] = None,
+        collection_id: Optional[str] = None,
+        conversation_id: Optional[str] = None,
+    ) -> Iterator[StreamEvent]:
+        """Generate a streamed AI response grounded in your documents.
+
+        Yields :class:`StreamEvent` objects with ``type`` and ``content``.
+        Event types:
+
+        - ``"sources"`` -- retrieved source chunks (list of dicts)
+        - ``"text"`` -- a chunk of generated text
+        - ``"done"`` -- stream complete
+        - ``"error"`` -- an error occurred
+
+        Parameters
+        ----------
+        message:
+            The user message / question.
+        method:
+            ``"vector"`` or ``"hybrid"``.
+        limit:
+            How many source chunks to retrieve (1--20).
+        document_ids:
+            Restrict to these document IDs.
+        collection_id:
+            Restrict to this collection.
+        conversation_id:
+            Continue an existing conversation thread.
+        """
+        body: Dict[str, Any] = {
+            "message": message,
+            "method": method,
+            "limit": limit,
+        }
+        if document_ids is not None:
+            body["document_ids"] = document_ids
+        if collection_id is not None:
+            body["collection_id"] = collection_id
+        if conversation_id is not None:
+            body["conversation_id"] = conversation_id
+
+        for event_data in self._client.stream_sse("POST", "/api/v1/responses", json_body=body):
+            event_type = event_data.get("type", "unknown")
+            content = event_data.get("content")
+            yield StreamEvent(type=event_type, content=content)

infratex/resources/searches.py

@@ -0,0 +1,54 @@
+"""Searches resource."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Dict, List, Optional
+
+from .._types import SearchResponse
+
+if TYPE_CHECKING:
+    from .._http import HTTPClient
+
+
+class Searches:
+    """Interact with the ``/api/v1/searches`` endpoint."""
+
+    def __init__(self, client: HTTPClient) -> None:
+        self._client = client
+
+    def create(
+        self,
+        *,
+        query: str,
+        method: str = "vector",
+        limit: int = 5,
+        document_ids: Optional[List[str]] = None,
+        collection_id: Optional[str] = None,
+    ) -> SearchResponse:
+        """Run a semantic or hybrid search across indexed documents.
+
+        Parameters
+        ----------
+        query:
+            The natural-language search query.
+        method:
+            ``"vector"`` or ``"hybrid"``.
+        limit:
+            Maximum number of results to return (1--50).
+        document_ids:
+            Restrict search to these document IDs.
+        collection_id:
+            Restrict search to this collection.
+        """
+        body: Dict[str, Any] = {
+            "query": query,
+            "method": method,
+            "limit": limit,
+        }
+        if document_ids is not None:
+            body["document_ids"] = document_ids
+        if collection_id is not None:
+            body["collection_id"] = collection_id
+
+        resp = self._client.request("POST", "/api/v1/searches", json_body=body)
+        return SearchResponse(resp)

infratex-0.1.0.dist-info/METADATA

@@ -0,0 +1,198 @@
+Metadata-Version: 2.4
+Name: infratex
+Version: 0.1.0
+Summary: Python SDK for the Infratex document intelligence API
+Project-URL: Homepage, https://infratex.io
+Project-URL: Documentation, https://docs.infratex.io
+Project-URL: Repository, https://github.com/infratex/infratex-python
+Author-email: Infratex <support@infratex.io>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: document,infratex,parsing,pdf,rag
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+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: Typing :: Typed
+Requires-Python: >=3.8
+Requires-Dist: httpx>=0.24.0
+Description-Content-Type: text/markdown
+
+# Infratex Python SDK
+
+Official Python client for the [Infratex](https://infratex.io) document intelligence API. Parse PDFs, build search indexes, and generate AI-powered answers grounded in your documents.
+
+## Installation
+
+```bash
+pip install infratex
+```
+
+## Quick start
+
+```python
+from infratex import Infratex
+
+client = Infratex(api_key="infratex_sk_...")
+
+# Upload and parse a PDF
+doc = client.documents.upload("report.pdf")
+print(doc.id, doc.status, doc.page_count)
+
+# Index for search
+index = client.documents.index(doc.id, method="vector")
+
+# Search
+results = client.searches.create(query="revenue growth", document_ids=[doc.id])
+for r in results:
+    print(r.score, r.content[:100])
+
+# AI response (streamed)
+for event in client.responses.create(message="Summarize the key findings", document_ids=[doc.id]):
+    if event.type == "text":
+        print(event.content, end="")
+    elif event.type == "sources":
+        print("Sources:", event.content)
+```
+
+## Authentication
+
+Pass your API key directly or set the `INFRATEX_API_KEY` environment variable:
+
+```python
+# Explicit
+client = Infratex(api_key="infratex_sk_...")
+
+# From environment
+import os
+os.environ["INFRATEX_API_KEY"] = "infratex_sk_..."
+client = Infratex()
+```
+
+## Resources
+
+### Documents
+
+```python
+# Upload
+doc = client.documents.upload("report.pdf")
+doc = client.documents.upload("report.pdf", method="standard", collection_id="col-id")
+
+# List
+docs = client.documents.list(limit=50, offset=0, collection_id="col-id")
+print(docs.total)
+for d in docs:
+    print(d.filename)
+
+# Get
+doc = client.documents.get("doc-id")
+
+# Download markdown
+md = client.documents.markdown("doc-id")
+
+# Delete
+client.documents.delete("doc-id")
+
+# Index
+index = client.documents.index("doc-id", method="hybrid")
+```
+
+### Searches
+
+```python
+results = client.searches.create(
+    query="What is the EBITDA?",
+    method="vector",
+    limit=5,
+    document_ids=["doc-id"],
+    collection_id="col-id",
+)
+for r in results:
+    print(r.score, r.content[:200])
+```
+
+### Responses (streaming)
+
+```python
+for event in client.responses.create(
+    message="Summarize the report",
+    method="hybrid",
+    limit=5,
+    document_ids=["doc-id"],
+    conversation_id="conv-id",
+):
+    if event.type == "text":
+        print(event.content, end="")
+    elif event.type == "sources":
+        print("Sources:", event.content)
+    elif event.type == "done":
+        print("\n--- Done ---")
+```
+
+### Collections
+
+```python
+col = client.collections.create(name="Q3 Reports")
+cols = client.collections.list()
+col = client.collections.get("col-id")
+client.collections.update("col-id", name="Q4 Reports")
+client.collections.delete("col-id")
+```
+
+### Conversations
+
+```python
+conv = client.conversations.create(title="Analysis")
+convs = client.conversations.list()
+conv = client.conversations.get("conv-id")  # includes messages
+client.conversations.delete("conv-id")
+```
+
+### Account & Billing
+
+```python
+account = client.account.get()
+print(account.tenant["email"])
+
+billing = client.billing.get()
+print(billing.balance_micros)
+```
+
+## Error handling
+
+```python
+from infratex import Infratex, InfratexError
+
+client = Infratex(api_key="infratex_sk_...")
+
+try:
+    doc = client.documents.get("nonexistent-id")
+except InfratexError as e:
+    print(e.status_code)  # 404
+    print(e.code)         # error code from the API
+    print(str(e))         # human-readable message
+```
+
+## Configuration
+
+```python
+client = Infratex(
+    api_key="infratex_sk_...",
+    base_url="https://api.infratex.io",  # custom base URL
+    timeout=60.0,                         # request timeout in seconds
+)
+
+# Use as a context manager
+with Infratex(api_key="infratex_sk_...") as client:
+    doc = client.documents.upload("report.pdf")
+```
+
+## License
+
+MIT

infratex-0.1.0.dist-info/RECORD

@@ -0,0 +1,16 @@
+infratex/__init__.py,sha256=jLHxlOqqsJGyWF88PqIpdaY1hpC5oFheomBS2fh8KOk,586
+infratex/_client.py,sha256=wnuoineJfpE8ZRYiokYBe6pTYg8RtSuvMMRO_HRA5W4,2400
+infratex/_http.py,sha256=zr17M7ohGfdx51uxX4iFD5k7OQt60Qi2yt8DlDQfcnw,5565
+infratex/_types.py,sha256=J8R6dIrHyt3dpCsi_gMKq1i3_5Zr7Y7RXbIQyc4Gcfs,5279
+infratex/resources/__init__.py,sha256=Ff6uglCd2qjiEWc092Yza3JInXNUVJBsVEAxkug4KUk,384
+infratex/resources/account.py,sha256=mQpT-NqkvNzUXlMgtTcVSobncqK_t602vOtiIdC3tzA,544
+infratex/resources/billing.py,sha256=89oup5A15BpK5p-tdY9M4Q4S1Ym3VUrccVh-RrWN3r8,547
+infratex/resources/collections.py,sha256=6rPo-huN-zirNT2jwXvWlHIOQ0U6dm9gStdxnqP58P8,1498
+infratex/resources/conversations.py,sha256=h8ct7zKkD8z7-9_lMcJZtruS_6smYdImsM59wzWnAG8,1588
+infratex/resources/documents.py,sha256=g5Y3rBRR3Sj4fWsTgTdJSxJcor-U383-pIxmNNr6iy8,3650
+infratex/resources/responses.py,sha256=VZgWTPhTFLViEaqokG4BphuFmPSMJ1WaV38QVKGGyCQ,2184
+infratex/resources/searches.py,sha256=HFWkAropTlp_8AgN4N5W8YipRj3snpdBadUYGpV_2nA,1486
+infratex-0.1.0.dist-info/METADATA,sha256=aXO6Qfq6VWuJcGPKyFP2VhexzZukK8TRQeattZuN5h0,4793
+infratex-0.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+infratex-0.1.0.dist-info/licenses/LICENSE,sha256=3rHxvsFpZj0vZKIrYtFcpPyqP2UcbfJE395E9NKFVDk,1065
+infratex-0.1.0.dist-info/RECORD,,

infratex-0.1.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

infratex-0.1.0.dist-info/licenses/LICENSE

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