python-open-router 0.3.2__py3-none-any.whl → 0.4.0__py3-none-any.whl

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/models.py

@@ -24,10 +24,23 @@ class KeyData(DataClassORJSONMixin):
     """The OpenRouter key data."""
 
     label: str
-    usage: int
+    usage: float
     is_provisioning_key: bool
-    limit_remaining: int | None
+    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
@@ -38,10 +51,11 @@ class KeysDataWrapper(DataClassORJSONMixin):
 
 
 @dataclass
-class CreateKeyDataWrapper(DataClassORJSONMixin):
-    """Wrapper for OpenRouter key data."""
+class KeyCreateResponse(DataClassORJSONMixin):
+    """Response from creating a key."""
 
-    data: CreatedKey
+    data: Key
+    key: str
 
 
 @dataclass
@@ -52,15 +66,44 @@ class Key(DataClassORJSONMixin):
     name: str
     label: str
     disabled: bool
-    limit: float
+    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(kw_only=True)
-class CreatedKey(Key):
-    """Created key."""
+@dataclass
+class KeyResponseWrapper(DataClassORJSONMixin):
+    """Wrapper for single key response."""
+
+    data: Key
+
+
+@dataclass
+class DeletedKeyResponse(DataClassORJSONMixin):
+    """Response after deleting a key."""
+
+    deleted: bool
 
-    key: str
+
+@dataclass
+class ModelResponseWrapper(DataClassORJSONMixin):
+    """Wrapper for single OpenRouter model response."""
+
+    data: Model
 
 
 @dataclass
@@ -75,25 +118,29 @@ class SupportedParameter(StrEnum):
 
     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"
-    TOK_K = "top_k"
     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"
-    MIN_P = "min_p"
     REPETITION_PENALTY = "repetition_penalty"
+    MIN_P = "min_p"
+    TOP_A = "top_a"
     LOGPROBS = "logprobs"
     LOGIT_BIAS = "logit_bias"
     TOP_LOGPROBS = "top_logprobs"
-    STRUCTURED_OUTPUTS = "structured_outputs"
     WEB_SEARCH_OPTIONS = "web_search_options"
-    TOP_A = "top_a"
+    VERBOSITY = "verbosity"
 
 
 class Modality(StrEnum):
@@ -104,14 +151,78 @@ class Modality(StrEnum):
     IMAGE = "image"
     FILE = "file"
     EMBEDDINGS = "embeddings"
+    VIDEO = "video"
+    RERANK = "rerank"
+    SPEECH = "speech"
+    TRANSCRIPTION = "transcription"
 
 
 @dataclass(kw_only=True)
 class ModelArchitecture(DataClassORJSONMixin):
-    """Model data."""
+    """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)
@@ -120,24 +231,34 @@ class Model(DataClassORJSONMixin):
 
     id: str
     canonical_slug: str
-    hugging_face_id: str | None
     name: str
-    description: str
-    context_length: int
+    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 SupportedParameter:
+            if parameter not in supported:
                 _LOGGER.warning(
                     "Unsupported parameter: %s. Please report at https://github.com/joostlek/python-open-router/issues.",
                     parameter,
                 )
-                parameters.remove(parameter)
         return d
 
     @classmethod
@@ -145,4 +266,6 @@ class Model(DataClassORJSONMixin):
         """Post deserialize hook."""
         if obj.hugging_face_id == "":
             obj.hugging_face_id = None
+        if obj.description == "":
+            obj.description = None
         return obj

python_open_router/open_router.py

@@ -9,17 +9,24 @@ import socket
 from typing import TYPE_CHECKING, Any
 
 from aiohttp import ClientError, ClientResponseError, ClientSession
-from aiohttp.hdrs import METH_GET, METH_POST
+from aiohttp.hdrs import METH_DELETE, METH_GET, METH_PATCH, METH_POST
+import orjson
 from yarl import URL
 
-from python_open_router.exceptions import OpenRouterConnectionError
+from python_open_router.exceptions import (
+    OpenRouterAuthenticationError,
+    OpenRouterConnectionError,
+)
 from python_open_router.models import (
-    CreateKeyDataWrapper,
+    DeletedKeyResponse,
     Key,
+    KeyCreateResponse,
     KeyData,
     KeyDataWrapper,
+    KeyResponseWrapper,
     KeysDataWrapper,
     Model,
+    ModelResponseWrapper,
     ModelsDataWrapper,
 )
 
@@ -81,6 +88,10 @@ class OpenRouterClient:
             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()
@@ -97,25 +108,162 @@ class OpenRouterClient:
         response = await self._request(METH_GET, "key")
         return KeyDataWrapper.from_json(response).data
 
-    async def get_keys(self) -> list[Key]:
+    async def get_keys(
+        self,
+        *,
+        include_disabled: bool | None = None,
+        offset: int | None = None,
+        workspace_id: str | None = None,
+    ) -> list[Key]:
         """Get all keys."""
-        response = await self._request(METH_GET, "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) -> Key:
+    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 CreateKeyDataWrapper.from_json(response).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(self) -> list[Model]:
+    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."""
-        response = await self._request(METH_GET, "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:

{python_open_router-0.3.2.dist-info → python_open_router-0.4.0.dist-info}/METADATA

@@ -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.4.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+python_open_router/__init__.py,sha256=9a8JXk66oCsPUc-XxgHBI29sVi6QbjlnUuCUxLDJUfo,1166
+python_open_router/exceptions.py,sha256=68nskqNdXNMIK4iA1XOE1E5P5rbhAf27DDACkk-ZVwU,312
+python_open_router/models.py,sha256=oVEE8q195laYFa7WXSYOKI6FiTqvJ6lPSTzTphj8eHI,6943
+python_open_router/open_router.py,sha256=JB_2fu1akGJ8niuP7FOlExWTV3ytDvmH_sXWKY5iO6I,9520
+python_open_router/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+python_open_router-0.4.0.dist-info/METADATA,sha256=Iv2GN34OuueJ3t0rUj_ELgoEFu-aHPYX7TvCm1XvSqU,6055
+python_open_router-0.4.0.dist-info/WHEEL,sha256=EGEvSphFYqXKs23-kQBeyNoJP1nrT8ZJKQoi5p5DYL8,88
+python_open_router-0.4.0.dist-info/licenses/LICENSE.md,sha256=Xbw7n2Ic30r4j8_MDNND4ss_sdoj9IGeIkEWc2Hsfs8,1077
+python_open_router-0.4.0.dist-info/RECORD,,

{python_open_router-0.3.2.dist-info → python_open_router-0.4.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 2.2.1
+Generator: poetry-core 2.4.0
 Root-Is-Purelib: true
 Tag: py3-none-any

python_open_router-0.3.2.dist-info/RECORD

@@ -1,9 +0,0 @@
-python_open_router/__init__.py,sha256=UQt6SpcnmQkS2wiyjwA_Ggvvzu7Ucx8BOCyZLZ_F2uA,840
-python_open_router/exceptions.py,sha256=68nskqNdXNMIK4iA1XOE1E5P5rbhAf27DDACkk-ZVwU,312
-python_open_router/models.py,sha256=-9e0k_8jmiaCdkiIJSKdm70389EeePnHgiRA5Phby3s,3359
-python_open_router/open_router.py,sha256=zq7aleWZfNFqbBb69Qp3_3jed95cwxtgGMlYFhDzYKw,4148
-python_open_router/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-python_open_router-0.3.2.dist-info/METADATA,sha256=tMbVeQcyCmNwxFUjfH7OmXrL1Ki4s9kisuvW2epnuPs,6055
-python_open_router-0.3.2.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
-python_open_router-0.3.2.dist-info/licenses/LICENSE.md,sha256=Xbw7n2Ic30r4j8_MDNND4ss_sdoj9IGeIkEWc2Hsfs8,1077
-python_open_router-0.3.2.dist-info/RECORD,,