rapid-api-client 0.7.2__tar.gz → 0.7.4__tar.gz

{rapid_api_client-0.7.2 → rapid_api_client-0.7.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: rapid-api-client
-Version: 0.7.2
+Version: 0.7.4
 Summary: Rapidly develop your API clients using decorators and annotations
 Author: Sébastien MB
 Author-email: seb@essembeh.org
@@ -27,8 +27,8 @@ Classifier: Topic :: Software Development :: Libraries
 Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Typing :: Typed
-Requires-Dist: httpx (>=0.28.1,<0.29.0)
-Requires-Dist: pydantic (>=2.9.2,<3.0.0)
+Requires-Dist: httpx (==0.*)
+Requires-Dist: pydantic (==2.*)
 Project-URL: Homepage, https://github.com/essembeh/rapid-api-client
 Project-URL: Issues, https://github.com/essembeh/rapid-api-client/issues
 Project-URL: Repository, https://github.com/essembeh/rapid-api-client

{rapid_api_client-0.7.2 → rapid_api_client-0.7.4}/pyproject.toml

@@ -3,7 +3,7 @@ name = "rapid-api-client"
 
 [tool.poetry]
 name = "rapid-api-client"
-version = "0.7.2"
+version = "0.7.4"
 description = "Rapidly develop your API clients using decorators and annotations"
 authors = ["Sébastien MB <seb@essembeh.org>"]
 readme = "README.md"
@@ -38,8 +38,8 @@ Issues = "https://github.com/essembeh/rapid-api-client/issues"
 
 [tool.poetry.dependencies]
 python = "^3.11"
-pydantic = "^2.9.2"
-httpx = "^0.28.1"
+pydantic = "2.*"
+httpx = "0.*"
 
 [tool.poetry.group.dev.dependencies]
 pytest = "*"

rapid_api_client-0.7.4/rapid_api_client/client.py

@@ -0,0 +1,96 @@
+"""
+Client classes for the rapid-api-client library.
+
+This module provides the core classes for building API clients:
+- RapidApi: Base class for API clients
+- ParameterManager: Manages parameters for API requests
+- RapidParameter: Represents a function parameter with its annotation
+
+These classes handle the extraction of parameters from function signatures,
+the resolution of path templates, and the building of HTTP requests.
+They work together with the decorator module to provide a declarative way
+to define API clients.
+"""
+
+from typing import (
+    Any,
+    Dict,
+)
+
+from httpx import AsyncClient, Client
+
+
+class RapidApi:
+    """
+    Base class for API clients.
+
+    This class represents an API client. Subclasses should define methods
+    decorated with @http (or @get, @post, etc.) which represent API endpoints.
+
+    Example:
+        >>> from rapid_api_client import RapidApi, get, post
+        >>> from typing import Annotated
+        >>>
+        >>> class MyApi(RapidApi):
+        ...     @get("/users/{user_id}")
+        ...     def get_user(self, user_id: Annotated[int, Path()]): ...
+        ...
+        ...     @post("/users")
+        ...     def create_user(self, user: Annotated[dict, JsonBody()]): ...
+        >>>
+        >>> api = MyApi(base_url="https://api.example.com")
+        >>> user = api.get_user(123)
+    """
+
+    def __init__(
+        self,
+        *,
+        client: Client | None = None,
+        async_client: AsyncClient | None = None,
+        **kwargs: Any,
+    ) -> None:
+        """
+        Initialize a RapidApi instance.
+
+        Args:
+            client: An existing httpx.Client instance to use for synchronous requests
+            async_client: An existing httpx.AsyncClient instance to use for asynchronous requests
+            **kwargs: Additional arguments to pass to the httpx.Client and httpx.AsyncClient
+                     constructors when creating new clients. Common arguments include:
+                     - base_url: The base URL for the API
+                     - headers: Default headers to include in all requests
+                     - timeout: Default timeout for requests
+        """
+        self._client: Client | None = client
+        self._async_client: AsyncClient | None = async_client
+        self.client_factory_args: Dict[str, Any] = kwargs
+
+    @property
+    def client(self) -> Client:
+        """
+        Get the synchronous HTTP client.
+
+        If no client was provided in the constructor, a new one is created
+        using the arguments provided in the constructor.
+
+        Returns:
+            The httpx.Client instance for making synchronous requests
+        """
+        if self._client is None:
+            self._client = Client(**self.client_factory_args)
+        return self._client
+
+    @property
+    def async_client(self) -> AsyncClient:
+        """
+        Get the asynchronous HTTP client.
+
+        If no async client was provided in the constructor, a new one is created
+        using the arguments provided in the constructor.
+
+        Returns:
+            The httpx.AsyncClient instance for making asynchronous requests
+        """
+        if self._async_client is None:
+            self._async_client = AsyncClient(**self.client_factory_args)
+        return self._async_client

{rapid_api_client-0.7.2 → rapid_api_client-0.7.4}/rapid_api_client/decorator.py

@@ -17,11 +17,12 @@ sending the requests, and processing the responses.
 import inspect
 from functools import partial, wraps
 from inspect import signature
-from typing import Any, Dict, Type
+from typing import Any, Callable, Dict, Optional, Type
 
-from httpx import Response
+from httpx import Request, Response
 
-from .client import ParameterManager, RapidApi
+from .client import RapidApi
+from .parameters import ParameterManager
 from .utils import process_response
 
 
@@ -31,6 +32,7 @@ def http(
     timeout: float | None = None,
     headers: Dict[str, str] | None = None,
     raise_for_status: bool = True,
+    request_tweaker: Optional[Callable[[Request], Request]] = None,
 ) -> Any:
     """
     Main decorator used to generate an HTTP request and return its result.
@@ -49,6 +51,7 @@ def http(
         timeout: Optional timeout for the request in seconds
         headers: Optional additional headers to include in the request
         raise_for_status: Whether to raise an exception for non-2xx status codes
+        request_tweaker: An optional function to modify the built request before sending it
 
     Returns:
         A decorator function that wraps the API endpoint method
@@ -95,11 +98,15 @@ def http(
                 for k, v in headers.items():
                     build_kwargs["headers"].setdefault(k, v)
 
-            return (
+            out = (
                 api.async_client.build_request(method, resolved_path, **build_kwargs)
                 if is_async
                 else api.client.build_request(method, resolved_path, **build_kwargs)
             )
+            # If a request tweaker is given, apply it
+            if request_tweaker is not None:
+                out = request_tweaker(out)
+            return out
 
         @wraps(func)
         async def async_wrapper(api: RapidApi, *args, **kwargs):

rapid_api_client-0.7.2/rapid_api_client/client.py → rapid_api_client-0.7.4/rapid_api_client/parameters.py

@@ -23,7 +23,6 @@ from typing import (
     Tuple,
 )
 
-from httpx import AsyncClient, Client
 from pydantic import BaseModel, TypeAdapter
 from pydantic_core import PydanticUndefined
 
@@ -310,79 +309,3 @@ class ParameterManager:
                     return "content", value
 
         return (None, None)
-
-
-class RapidApi:
-    """
-    Base class for API clients.
-
-    This class represents an API client. Subclasses should define methods
-    decorated with @http (or @get, @post, etc.) which represent API endpoints.
-
-    Example:
-        >>> from rapid_api_client import RapidApi, get, post
-        >>> from typing import Annotated
-        >>>
-        >>> class MyApi(RapidApi):
-        ...     @get("/users/{user_id}")
-        ...     def get_user(self, user_id: Annotated[int, Path()]): ...
-        ...
-        ...     @post("/users")
-        ...     def create_user(self, user: Annotated[dict, JsonBody()]): ...
-        >>>
-        >>> api = MyApi(base_url="https://api.example.com")
-        >>> user = api.get_user(123)
-    """
-
-    def __init__(
-        self,
-        *,
-        client: Client | None = None,
-        async_client: AsyncClient | None = None,
-        **kwargs: Any,
-    ) -> None:
-        """
-        Initialize a RapidApi instance.
-
-        Args:
-            client: An existing httpx.Client instance to use for synchronous requests
-            async_client: An existing httpx.AsyncClient instance to use for asynchronous requests
-            **kwargs: Additional arguments to pass to the httpx.Client and httpx.AsyncClient
-                     constructors when creating new clients. Common arguments include:
-                     - base_url: The base URL for the API
-                     - headers: Default headers to include in all requests
-                     - timeout: Default timeout for requests
-        """
-        self._client: Client | None = client
-        self._async_client: AsyncClient | None = async_client
-        self.client_factory_args: Dict[str, Any] = kwargs
-
-    @property
-    def client(self) -> Client:
-        """
-        Get the synchronous HTTP client.
-
-        If no client was provided in the constructor, a new one is created
-        using the arguments provided in the constructor.
-
-        Returns:
-            The httpx.Client instance for making synchronous requests
-        """
-        if self._client is None:
-            self._client = Client(**self.client_factory_args)
-        return self._client
-
-    @property
-    def async_client(self) -> AsyncClient:
-        """
-        Get the asynchronous HTTP client.
-
-        If no async client was provided in the constructor, a new one is created
-        using the arguments provided in the constructor.
-
-        Returns:
-            The httpx.AsyncClient instance for making asynchronous requests
-        """
-        if self._async_client is None:
-            self._async_client = AsyncClient(**self.client_factory_args)
-        return self._async_client