python-open-router 0.3.2__tar.gz → 0.4.0__tar.gz

{python_open_router-0.3.2 → python_open_router-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python_open_router
-Version: 0.3.2
+Version: 0.4.0
 Summary: Asynchronous Python client for Open Router.
 License: MIT
 License-File: LICENSE.md

{python_open_router-0.3.2 → python_open_router-0.4.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "python_open_router"
-version = "0.3.2"
+version = "0.4.0"
 description = "Asynchronous Python client for Open Router."
 authors = ["Joost Lekkerkerker <joostlek@outlook.com>"]
 maintainers = ["Joost Lekkerkerker <joostlek@outlook.com>"]
@@ -32,21 +32,21 @@ mashumaro = "^3.11"
 orjson = ">=3.9.0"
 
 [tool.poetry.group.dev.dependencies]
-codespell = "2.4.1"
+codespell = "2.4.2"
 covdefaults = "2.3.0"
-coverage = {version = "7.11.0", extras = ["toml"]}
-mypy = "1.18.2"
-pre-commit = "4.3.0"
+coverage = {version = "7.15.0", extras = ["toml"]}
+mypy = "2.2.0"
+pre-commit = "4.6.0"
 pre-commit-hooks = "6.0.0"
-pylint = "4.0.2"
-pytest = "8.4.2"
-pytest-asyncio = "1.2.0"
-pytest-cov = "7.0.0"
-ruff = "0.14.3"
-safety = "3.6.2"
-yamllint = "1.37.1"
-syrupy = "5.0.0"
-aioresponses = "0.7.8"
+pylint = "4.0.6"
+pytest = "9.1.1"
+pytest-asyncio = "1.4.0"
+pytest-cov = "7.1.0"
+ruff = "0.15.21"
+safety = "3.8.1"
+yamllint = "1.38.0"
+syrupy = "5.5.2"
+aioresponses = "0.7.9"
 
 [tool.poetry.urls]
 "Bug Tracker" = "https://github.com/joostlek/python-open-router/issues"
@@ -141,6 +141,8 @@ ignore = [
   "D213", # Conflicts with other rules
   "D417", # False positives in some occasions
   "ISC001", # Conflicts with other rules
+  "PLR0912", # Too many branches - legitimate for API client methods
+  "PLR0913", # Too many arguments - legitimate for API client methods
   "PLR2004", # Just annoying, not really useful
 ]
 select = ["ALL"]

{python_open_router-0.3.2 → python_open_router-0.4.0}/src/python_open_router/__init__.py

@@ -6,34 +6,48 @@ from python_open_router.exceptions import (
     OpenRouterError,
 )
 from python_open_router.models import (
-    CreatedKey,
-    CreateKeyDataWrapper,
+    DefaultParameters,
+    DeletedKeyResponse,
     Key,
+    KeyCreateResponse,
     KeyData,
     KeyDataWrapper,
+    KeyResponseWrapper,
     KeysDataWrapper,
     Modality,
     Model,
     ModelArchitecture,
+    ModelLinks,
+    ModelResponseWrapper,
     ModelsDataWrapper,
+    PerRequestLimits,
+    PublicPricing,
     SupportedParameter,
+    TopProviderInfo,
 )
 from python_open_router.open_router import OpenRouterClient
 
 __all__ = [
-    "CreateKeyDataWrapper",
-    "CreatedKey",
+    "DefaultParameters",
+    "DeletedKeyResponse",
     "Key",
+    "KeyCreateResponse",
     "KeyData",
     "KeyDataWrapper",
+    "KeyResponseWrapper",
     "KeysDataWrapper",
     "Modality",
     "Model",
     "ModelArchitecture",
+    "ModelLinks",
+    "ModelResponseWrapper",
     "ModelsDataWrapper",
     "OpenRouterAuthenticationError",
     "OpenRouterClient",
     "OpenRouterConnectionError",
     "OpenRouterError",
+    "PerRequestLimits",
+    "PublicPricing",
     "SupportedParameter",
+    "TopProviderInfo",
 ]

python_open_router-0.4.0/src/python_open_router/models.py

@@ -0,0 +1,271 @@
+"""Models for OpenRouter."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import StrEnum
+import logging
+from typing import Any
+
+from mashumaro.mixins.orjson import DataClassORJSONMixin
+
+_LOGGER = logging.getLogger(__package__)
+
+
+@dataclass
+class KeyDataWrapper(DataClassORJSONMixin):
+    """Wrapper for OpenRouter key data."""
+
+    data: KeyData
+
+
+@dataclass
+class KeyData(DataClassORJSONMixin):
+    """The OpenRouter key data."""
+
+    label: str
+    usage: float
+    is_provisioning_key: bool
+    limit_remaining: float | None
+    is_free_tier: bool
+    limit: float | None = None
+    limit_reset: str | None = None
+    usage_daily: float = 0.0
+    usage_weekly: float = 0.0
+    usage_monthly: float = 0.0
+    byok_usage: float = 0.0
+    byok_usage_daily: float = 0.0
+    byok_usage_weekly: float = 0.0
+    byok_usage_monthly: float = 0.0
+    include_byok_in_limit: bool = False
+    is_management_key: bool = False
+    creator_user_id: str | None = None
+    expires_at: str | None = None
+
+
+@dataclass
+class KeysDataWrapper(DataClassORJSONMixin):
+    """Wrapper for OpenRouter key data."""
+
+    data: list[Key]
+
+
+@dataclass
+class KeyCreateResponse(DataClassORJSONMixin):
+    """Response from creating a key."""
+
+    data: Key
+    key: str
+
+
+@dataclass
+class Key(DataClassORJSONMixin):
+    """The OpenRouter key data."""
+
+    hash: str
+    name: str
+    label: str
+    disabled: bool
+    limit: float | None = None
+    usage: float = 0.0
+    created_at: str = ""
+    updated_at: str | None = None
+    limit_remaining: float | None = None
+    limit_reset: str | None = None
+    workspace_id: str = ""
+    expires_at: str | None = None
+    usage_daily: float = 0.0
+    usage_weekly: float = 0.0
+    usage_monthly: float = 0.0
+    byok_usage: float = 0.0
+    byok_usage_daily: float = 0.0
+    byok_usage_weekly: float = 0.0
+    byok_usage_monthly: float = 0.0
+    include_byok_in_limit: bool = False
+    creator_user_id: str | None = None
+
+
+@dataclass
+class KeyResponseWrapper(DataClassORJSONMixin):
+    """Wrapper for single key response."""
+
+    data: Key
+
+
+@dataclass
+class DeletedKeyResponse(DataClassORJSONMixin):
+    """Response after deleting a key."""
+
+    deleted: bool
+
+
+@dataclass
+class ModelResponseWrapper(DataClassORJSONMixin):
+    """Wrapper for single OpenRouter model response."""
+
+    data: Model
+
+
+@dataclass
+class ModelsDataWrapper(DataClassORJSONMixin):
+    """Wrapper for OpenRouter model data."""
+
+    data: list[Model]
+
+
+class SupportedParameter(StrEnum):
+    """Supported parameters for models."""
+
+    TEMPERATURE = "temperature"
+    TOP_P = "top_p"
+    TOP_K = "top_k"
+    MAX_TOKENS = "max_tokens"
+    MAX_COMPLETION_TOKENS = "max_completion_tokens"
+    REASONING = "reasoning"
+    REASONING_EFFORT = "reasoning_effort"
+    INCLUDE_REASONING = "include_reasoning"
+    STOP = "stop"
+    SEED = "seed"
+    RESPONSE_FORMAT = "response_format"
+    STRUCTURED_OUTPUTS = "structured_outputs"
+    TOOLS = "tools"
+    TOOL_CHOICE = "tool_choice"
+    PARALLEL_TOOL_CALLS = "parallel_tool_calls"
+    FREQUENCY_PENALTY = "frequency_penalty"
+    PRESENCE_PENALTY = "presence_penalty"
+    REPETITION_PENALTY = "repetition_penalty"
+    MIN_P = "min_p"
+    TOP_A = "top_a"
+    LOGPROBS = "logprobs"
+    LOGIT_BIAS = "logit_bias"
+    TOP_LOGPROBS = "top_logprobs"
+    WEB_SEARCH_OPTIONS = "web_search_options"
+    VERBOSITY = "verbosity"
+
+
+class Modality(StrEnum):
+    """Supported modalities for models."""
+
+    AUDIO = "audio"
+    TEXT = "text"
+    IMAGE = "image"
+    FILE = "file"
+    EMBEDDINGS = "embeddings"
+    VIDEO = "video"
+    RERANK = "rerank"
+    SPEECH = "speech"
+    TRANSCRIPTION = "transcription"
+
+
+@dataclass(kw_only=True)
+class ModelArchitecture(DataClassORJSONMixin):
+    """Model architecture data."""
+
+    input_modalities: list[Modality]
+    output_modalities: list[Modality]
+    modality: str | None = None
+    instruct_type: str | None = None
+    tokenizer: str | None = None
+
+
+@dataclass(kw_only=True)
+class PublicPricing(DataClassORJSONMixin):
+    """Model pricing data."""
+
+    completion: str
+    prompt: str
+    audio: str | None = None
+    audio_output: str | None = None
+    image: str | None = None
+    image_output: str | None = None
+    image_token: str | None = None
+    input_audio_cache: str | None = None
+    input_cache_read: str | None = None
+    input_cache_write: str | None = None
+    input_cache_write_1h: str | None = None
+    internal_reasoning: str | None = None
+    request: str | None = None
+    web_search: str | None = None
+    discount: float | None = None
+
+
+@dataclass(kw_only=True)
+class TopProviderInfo(DataClassORJSONMixin):
+    """Top provider information."""
+
+    is_moderated: bool
+    context_length: int | None = None
+    max_completion_tokens: int | None = None
+
+
+@dataclass(kw_only=True)
+class DefaultParameters(DataClassORJSONMixin):
+    """Default model parameters."""
+
+    temperature: float | None = None
+    top_p: float | None = None
+    top_k: int | None = None
+    frequency_penalty: float | None = None
+    presence_penalty: float | None = None
+    repetition_penalty: float | None = None
+
+
+@dataclass(kw_only=True)
+class PerRequestLimits(DataClassORJSONMixin):
+    """Per-request limits."""
+
+    completion_tokens: float
+    prompt_tokens: float
+
+
+@dataclass(kw_only=True)
+class ModelLinks(DataClassORJSONMixin):
+    """Model links."""
+
+    details: str
+
+
+@dataclass(kw_only=True)
+class Model(DataClassORJSONMixin):
+    """Model data."""
+
+    id: str
+    canonical_slug: str
+    name: str
+    context_length: int | None
+    architecture: ModelArchitecture
+    supported_parameters: list[SupportedParameter]
+    pricing: PublicPricing
+    top_provider: TopProviderInfo
+    hugging_face_id: str | None = None
+    description: str | None = None
+    created: int | None = None
+    default_parameters: DefaultParameters | None = None
+    links: ModelLinks | None = None
+    per_request_limits: PerRequestLimits | None = None
+    supported_voices: list[str] | None = None
+    expiration_date: str | None = None
+    knowledge_cutoff: str | None = None
+
+    @classmethod
+    def __pre_deserialize__(cls, d: dict[str, Any]) -> dict[str, Any]:
+        """Pre deserialize hook."""
+        parameters = d.get("supported_parameters", [])
+        supported = set(SupportedParameter)
+        d["supported_parameters"] = [p for p in parameters if p in supported]
+        for parameter in parameters:
+            if parameter not in supported:
+                _LOGGER.warning(
+                    "Unsupported parameter: %s. Please report at https://github.com/joostlek/python-open-router/issues.",
+                    parameter,
+                )
+        return d
+
+    @classmethod
+    def __post_deserialize__(cls, obj: Model) -> Model:
+        """Post deserialize hook."""
+        if obj.hugging_face_id == "":
+            obj.hugging_face_id = None
+        if obj.description == "":
+            obj.description = None
+        return obj

python_open_router-0.4.0/src/python_open_router/open_router.py

@@ -0,0 +1,290 @@
+"""Asynchronous Python client for Open Router."""
+
+from __future__ import annotations
+
+import asyncio
+from dataclasses import dataclass
+from importlib import metadata
+import socket
+from typing import TYPE_CHECKING, Any
+
+from aiohttp import ClientError, ClientResponseError, ClientSession
+from aiohttp.hdrs import METH_DELETE, METH_GET, METH_PATCH, METH_POST
+import orjson
+from yarl import URL
+
+from python_open_router.exceptions import (
+    OpenRouterAuthenticationError,
+    OpenRouterConnectionError,
+)
+from python_open_router.models import (
+    DeletedKeyResponse,
+    Key,
+    KeyCreateResponse,
+    KeyData,
+    KeyDataWrapper,
+    KeyResponseWrapper,
+    KeysDataWrapper,
+    Model,
+    ModelResponseWrapper,
+    ModelsDataWrapper,
+)
+
+if TYPE_CHECKING:
+    from typing_extensions import Self
+
+
+VERSION = metadata.version(__package__)
+HOST = "openrouter.ai"
+
+
+@dataclass
+class OpenRouterClient:
+    """Main class for handling connections with OpenRouter."""
+
+    api_key: str
+    session: ClientSession | None = None
+    request_timeout: int = 10
+    _close_session: bool = False
+
+    async def _request(
+        self,
+        method: str,
+        uri: str,
+        *,
+        params: dict[str, Any] | None = None,
+        data: dict[str, Any] | None = None,
+    ) -> str:
+        """Handle a request to OpenRouter."""
+        url = URL.build(host=HOST, scheme="https").joinpath(f"api/v1/{uri}")
+
+        headers = {
+            "User-Agent": f"PythonOpenRouter/{VERSION}",
+            "Accept": "application/json",
+            "Authorization": f"Bearer {self.api_key}",
+        }
+
+        if self.session is None:
+            self.session = ClientSession()
+            self._close_session = True
+
+        try:
+            async with asyncio.timeout(self.request_timeout):
+                response = await self.session.request(
+                    method,
+                    url,
+                    params=params,
+                    headers=headers,
+                    json=data,
+                )
+        except asyncio.TimeoutError as exception:
+            msg = "Timeout occurred while connecting to the service"
+            raise OpenRouterConnectionError(msg) from exception
+        except (
+            ClientError,
+            ClientResponseError,
+            socket.gaierror,
+        ) as exception:
+            msg = "Error occurred while communicating with the service"
+            raise OpenRouterConnectionError(msg) from exception
+
+        if response.status == 401:
+            msg = "Authentication failed"
+            raise OpenRouterAuthenticationError(msg)
+
+        if response.status >= 400:
+            content_type = response.headers.get("Content-Type", "")
+            text = await response.text()
+            msg = "Unexpected response from OpenRouter"
+            raise OpenRouterConnectionError(
+                msg,
+                {"Content-Type": content_type, "response": text},
+            )
+
+        return await response.text()
+
+    async def get_key_data(self) -> KeyData:
+        """Get key data for API key."""
+        response = await self._request(METH_GET, "key")
+        return KeyDataWrapper.from_json(response).data
+
+    async def get_keys(
+        self,
+        *,
+        include_disabled: bool | None = None,
+        offset: int | None = None,
+        workspace_id: str | None = None,
+    ) -> list[Key]:
+        """Get all keys."""
+        params: dict[str, Any] = {}
+        if include_disabled is not None:
+            params["include_disabled"] = str(include_disabled).lower()
+        if offset is not None:
+            params["offset"] = str(offset)
+        if workspace_id is not None:
+            params["workspace_id"] = workspace_id
+        response = await self._request(METH_GET, "keys", params=params or None)
+        return KeysDataWrapper.from_json(response).data
+
+    async def create_key(
+        self,
+        name: str,
+        limit: float | None = None,
+        *,
+        limit_reset: str | None = None,
+        workspace_id: str | None = None,
+        expires_at: str | None = None,
+        include_byok_in_limit: bool | None = None,
+    ) -> Key:
+        """Create a new key."""
+        data: dict[str, Any] = {"name": name}
+        if limit is not None:
+            data["limit"] = limit
+        if limit_reset is not None:
+            data["limit_reset"] = limit_reset
+        if workspace_id is not None:
+            data["workspace_id"] = workspace_id
+        if expires_at is not None:
+            data["expires_at"] = expires_at
+        if include_byok_in_limit is not None:
+            data["include_byok_in_limit"] = include_byok_in_limit
+
+        response = await self._request(METH_POST, "keys", data=data)
+        return KeyCreateResponse.from_json(response).data
+
+    async def get_key(self, key_hash: str) -> Key:
+        """Get a single key by hash."""
+        response = await self._request(METH_GET, f"keys/{key_hash}")
+        return KeyResponseWrapper.from_json(response).data
+
+    async def update_key(
+        self,
+        key_hash: str,
+        *,
+        name: str | None = None,
+        disabled: bool | None = None,
+        limit: float | None = None,
+        limit_reset: str | None = None,
+        include_byok_in_limit: bool | None = None,
+    ) -> Key:
+        """Update an existing key."""
+        data: dict[str, Any] = {}
+        if name is not None:
+            data["name"] = name
+        if disabled is not None:
+            data["disabled"] = disabled
+        if limit is not None:
+            data["limit"] = limit
+        if limit_reset is not None:
+            data["limit_reset"] = limit_reset
+        if include_byok_in_limit is not None:
+            data["include_byok_in_limit"] = include_byok_in_limit
+
+        response = await self._request(METH_PATCH, f"keys/{key_hash}", data=data)
+        return KeyResponseWrapper.from_json(response).data
+
+    async def delete_key(self, key_hash: str) -> bool:
+        """Delete a key by hash."""
+        response = await self._request(METH_DELETE, f"keys/{key_hash}")
+        return DeletedKeyResponse.from_json(response).deleted
+
+    async def get_model(self, author: str, slug: str) -> Model:
+        """Get a single model by author and slug."""
+        response = await self._request(METH_GET, f"model/{author}/{slug}")
+        return ModelResponseWrapper.from_json(response).data
+
+    @staticmethod
+    def _filter_model_params(
+        kwargs: dict[str, Any],
+        *,
+        numeric_keys: frozenset[str] = frozenset(),
+    ) -> dict[str, Any]:
+        """Filter None values and convert numeric params to strings."""
+        params = {k: v for k, v in kwargs.items() if v is not None}
+        for key in numeric_keys:
+            if key in params:
+                params[key] = str(params[key])
+        return params
+
+    async def get_models(  # pylint: disable=too-many-locals
+        self,
+        *,
+        category: str | None = None,
+        supported_parameters: str | None = None,
+        output_modalities: str | None = None,
+        sort: str | None = None,
+        q: str | None = None,
+        input_modalities: str | None = None,
+        context: int | None = None,
+        min_price: float | None = None,
+        max_price: float | None = None,
+        arch: str | None = None,
+        model_authors: str | None = None,
+        providers: str | None = None,
+        distillable: str | None = None,
+        zdr: str | None = None,
+        region: str | None = None,
+    ) -> list[Model]:
+        """Get all available models."""
+        numeric = frozenset({"context", "min_price", "max_price"})
+        params = self._filter_model_params(
+            {
+                "category": category,
+                "supported_parameters": supported_parameters,
+                "output_modalities": output_modalities,
+                "sort": sort,
+                "q": q,
+                "input_modalities": input_modalities,
+                "context": context,
+                "min_price": min_price,
+                "max_price": max_price,
+                "arch": arch,
+                "model_authors": model_authors,
+                "providers": providers,
+                "distillable": distillable,
+                "zdr": zdr,
+                "region": region,
+            },
+            numeric_keys=numeric,
+        )
+        response = await self._request(METH_GET, "models", params=params or None)
+        return ModelsDataWrapper.from_json(response).data
+
+    async def count_models(
+        self,
+        *,
+        output_modalities: str | None = None,
+    ) -> int:
+        """Get total count of available models."""
+        params: dict[str, Any] = {}
+        if output_modalities is not None:
+            params["output_modalities"] = output_modalities
+        response = await self._request(METH_GET, "models/count", params=params or None)
+        result: dict[str, Any] = orjson.loads(response)  # pylint: disable=no-member
+        count: int = result.get("data", {}).get("count", 0)
+        return count
+
+    async def close(self) -> None:
+        """Close open client session."""
+        if self.session and self._close_session:
+            await self.session.close()
+
+    async def __aenter__(self) -> Self:
+        """Async enter.
+
+        Returns
+        -------
+            The OpenRouterClient object.
+
+        """
+        return self
+
+    async def __aexit__(self, *_exc_info: object) -> None:
+        """Async exit.
+
+        Args:
+        ----
+            _exc_info: Exec type.
+
+        """
+        await self.close()

python_open_router-0.3.2/src/python_open_router/models.py

@@ -1,148 +0,0 @@
-"""Models for OpenRouter."""
-
-from __future__ import annotations
-
-from dataclasses import dataclass
-from enum import StrEnum
-import logging
-from typing import Any
-
-from mashumaro.mixins.orjson import DataClassORJSONMixin
-
-_LOGGER = logging.getLogger(__package__)
-
-
-@dataclass
-class KeyDataWrapper(DataClassORJSONMixin):
-    """Wrapper for OpenRouter key data."""
-
-    data: KeyData
-
-
-@dataclass
-class KeyData(DataClassORJSONMixin):
-    """The OpenRouter key data."""
-
-    label: str
-    usage: int
-    is_provisioning_key: bool
-    limit_remaining: int | None
-    is_free_tier: bool
-
-
-@dataclass
-class KeysDataWrapper(DataClassORJSONMixin):
-    """Wrapper for OpenRouter key data."""
-
-    data: list[Key]
-
-
-@dataclass
-class CreateKeyDataWrapper(DataClassORJSONMixin):
-    """Wrapper for OpenRouter key data."""
-
-    data: CreatedKey
-
-
-@dataclass
-class Key(DataClassORJSONMixin):
-    """The OpenRouter key data."""
-
-    hash: str
-    name: str
-    label: str
-    disabled: bool
-    limit: float
-    usage: float = 0.0
-
-
-@dataclass(kw_only=True)
-class CreatedKey(Key):
-    """Created key."""
-
-    key: str
-
-
-@dataclass
-class ModelsDataWrapper(DataClassORJSONMixin):
-    """Wrapper for OpenRouter model data."""
-
-    data: list[Model]
-
-
-class SupportedParameter(StrEnum):
-    """Supported parameters for models."""
-
-    TEMPERATURE = "temperature"
-    TOP_P = "top_p"
-    MAX_TOKENS = "max_tokens"
-    REASONING = "reasoning"
-    INCLUDE_REASONING = "include_reasoning"
-    STOP = "stop"
-    TOK_K = "top_k"
-    SEED = "seed"
-    RESPONSE_FORMAT = "response_format"
-    TOOLS = "tools"
-    TOOL_CHOICE = "tool_choice"
-    FREQUENCY_PENALTY = "frequency_penalty"
-    PRESENCE_PENALTY = "presence_penalty"
-    MIN_P = "min_p"
-    REPETITION_PENALTY = "repetition_penalty"
-    LOGPROBS = "logprobs"
-    LOGIT_BIAS = "logit_bias"
-    TOP_LOGPROBS = "top_logprobs"
-    STRUCTURED_OUTPUTS = "structured_outputs"
-    WEB_SEARCH_OPTIONS = "web_search_options"
-    TOP_A = "top_a"
-
-
-class Modality(StrEnum):
-    """Supported modalities for models."""
-
-    AUDIO = "audio"
-    TEXT = "text"
-    IMAGE = "image"
-    FILE = "file"
-    EMBEDDINGS = "embeddings"
-
-
-@dataclass(kw_only=True)
-class ModelArchitecture(DataClassORJSONMixin):
-    """Model data."""
-
-    input_modalities: list[Modality]
-    output_modalities: list[Modality]
-
-
-@dataclass(kw_only=True)
-class Model(DataClassORJSONMixin):
-    """Model data."""
-
-    id: str
-    canonical_slug: str
-    hugging_face_id: str | None
-    name: str
-    description: str
-    context_length: int
-    architecture: ModelArchitecture
-    supported_parameters: list[SupportedParameter]
-
-    @classmethod
-    def __pre_deserialize__(cls, d: dict[str, Any]) -> dict[str, Any]:
-        """Pre deserialize hook."""
-        parameters = d.get("supported_parameters", [])
-        for parameter in parameters:
-            if parameter not in SupportedParameter:
-                _LOGGER.warning(
-                    "Unsupported parameter: %s. Please report at https://github.com/joostlek/python-open-router/issues.",
-                    parameter,
-                )
-                parameters.remove(parameter)
-        return d
-
-    @classmethod
-    def __post_deserialize__(cls, obj: Model) -> Model:
-        """Post deserialize hook."""
-        if obj.hugging_face_id == "":
-            obj.hugging_face_id = None
-        return obj

python_open_router-0.3.2/src/python_open_router/open_router.py

@@ -1,142 +0,0 @@
-"""Asynchronous Python client for Open Router."""
-
-from __future__ import annotations
-
-import asyncio
-from dataclasses import dataclass
-from importlib import metadata
-import socket
-from typing import TYPE_CHECKING, Any
-
-from aiohttp import ClientError, ClientResponseError, ClientSession
-from aiohttp.hdrs import METH_GET, METH_POST
-from yarl import URL
-
-from python_open_router.exceptions import OpenRouterConnectionError
-from python_open_router.models import (
-    CreateKeyDataWrapper,
-    Key,
-    KeyData,
-    KeyDataWrapper,
-    KeysDataWrapper,
-    Model,
-    ModelsDataWrapper,
-)
-
-if TYPE_CHECKING:
-    from typing_extensions import Self
-
-
-VERSION = metadata.version(__package__)
-HOST = "openrouter.ai"
-
-
-@dataclass
-class OpenRouterClient:
-    """Main class for handling connections with OpenRouter."""
-
-    api_key: str
-    session: ClientSession | None = None
-    request_timeout: int = 10
-    _close_session: bool = False
-
-    async def _request(
-        self,
-        method: str,
-        uri: str,
-        *,
-        params: dict[str, Any] | None = None,
-        data: dict[str, Any] | None = None,
-    ) -> str:
-        """Handle a request to OpenRouter."""
-        url = URL.build(host=HOST, scheme="https").joinpath(f"api/v1/{uri}")
-
-        headers = {
-            "User-Agent": f"PythonOpenRouter/{VERSION}",
-            "Accept": "application/json",
-            "Authorization": f"Bearer {self.api_key}",
-        }
-
-        if self.session is None:
-            self.session = ClientSession()
-            self._close_session = True
-
-        try:
-            async with asyncio.timeout(self.request_timeout):
-                response = await self.session.request(
-                    method,
-                    url,
-                    params=params,
-                    headers=headers,
-                    json=data,
-                )
-        except asyncio.TimeoutError as exception:
-            msg = "Timeout occurred while connecting to the service"
-            raise OpenRouterConnectionError(msg) from exception
-        except (
-            ClientError,
-            ClientResponseError,
-            socket.gaierror,
-        ) as exception:
-            msg = "Error occurred while communicating with the service"
-            raise OpenRouterConnectionError(msg) from exception
-
-        if response.status >= 400:
-            content_type = response.headers.get("Content-Type", "")
-            text = await response.text()
-            msg = "Unexpected response from OpenRouter"
-            raise OpenRouterConnectionError(
-                msg,
-                {"Content-Type": content_type, "response": text},
-            )
-
-        return await response.text()
-
-    async def get_key_data(self) -> KeyData:
-        """Get key data for API key."""
-        response = await self._request(METH_GET, "key")
-        return KeyDataWrapper.from_json(response).data
-
-    async def get_keys(self) -> list[Key]:
-        """Get all keys."""
-        response = await self._request(METH_GET, "keys")
-        return KeysDataWrapper.from_json(response).data
-
-    async def create_key(self, name: str, limit: float | None = None) -> Key:
-        """Create a new key."""
-        data: dict[str, Any] = {"name": name}
-        if limit is not None:
-            data["limit"] = limit
-
-        response = await self._request(METH_POST, "keys", data=data)
-        return CreateKeyDataWrapper.from_json(response).data
-
-    async def get_models(self) -> list[Model]:
-        """Get all available models."""
-        response = await self._request(METH_GET, "models")
-        return ModelsDataWrapper.from_json(response).data
-
-    async def close(self) -> None:
-        """Close open client session."""
-        if self.session and self._close_session:
-            await self.session.close()
-
-    async def __aenter__(self) -> Self:
-        """Async enter.
-
-        Returns
-        -------
-            The OpenRouterClient object.
-
-        """
-        return self
-
-    async def __aexit__(self, *_exc_info: object) -> None:
-        """Async exit.
-
-        Args:
-        ----
-            _exc_info: Exec type.
-
-        """
-        await self.close()