rapid-api-client 0.3.1__tar.gz → 0.3.2__tar.gz

{rapid_api_client-0.3.1 → rapid_api_client-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: rapid-api-client
-Version: 0.3.1
+Version: 0.3.2
 Summary: Rapidly develop your API clients using decorators and annotations
 Author: Sébastien MB
 Author-email: seb@essembeh.org
@@ -65,7 +65,7 @@ class GithubIssuesApi(RapidApi):
     async def list_issues(self, owner: Annotated[str, Path()], repo: Annotated[str, Path()]): ...
 
     @get("/repos/{owner}/{repo}/releases", response_class=TypeAdapter(List[Release]))
-    async def list_issues(self, owner: Annotated[str, Path()], repo: Annotated[str, Path()]): ...
+    async def list_releases(self, owner: Annotated[str, Path()], repo: Annotated[str, Path()]): ...
 
 ```
 
@@ -109,7 +109,7 @@ class MyApi(RapidApi)
     async def post(self): ...
 
     @delete("/anything")
-    async ef delete(self): ...
+    async def delete(self): ...
 ```
 
 
@@ -245,3 +245,4 @@ class MyApi(RapidApi)
  # Examples
 
  See [example directory](./examples/) for some examples
+

{rapid_api_client-0.3.1 → rapid_api_client-0.3.2}/README.md

@@ -33,7 +33,7 @@ class GithubIssuesApi(RapidApi):
     async def list_issues(self, owner: Annotated[str, Path()], repo: Annotated[str, Path()]): ...
 
     @get("/repos/{owner}/{repo}/releases", response_class=TypeAdapter(List[Release]))
-    async def list_issues(self, owner: Annotated[str, Path()], repo: Annotated[str, Path()]): ...
+    async def list_releases(self, owner: Annotated[str, Path()], repo: Annotated[str, Path()]): ...
 
 ```
 
@@ -77,7 +77,7 @@ class MyApi(RapidApi)
     async def post(self): ...
 
     @delete("/anything")
-    async ef delete(self): ...
+    async def delete(self): ...
 ```
 
 
@@ -212,4 +212,4 @@ class MyApi(RapidApi)
 
  # Examples
 
- See [example directory](./examples/) for some examples
+ See [example directory](./examples/) for some examples

{rapid_api_client-0.3.1 → rapid_api_client-0.3.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "rapid-api-client"
-version = "0.3.1"
+version = "0.3.2"
 description = "Rapidly develop your API clients using decorators and annotations"
 authors = ["Sébastien MB <seb@essembeh.org>"]
 readme = "README.md"
@@ -44,6 +44,8 @@ pytest-asyncio = "^0.24.0"
 pytest-cov = "^5.0.0"
 pytest-dotenv = {extras = ["cli"], version = "^0.5.2"}
 pydantic-xml = "^2.13.0"
+mypy = "^1.11.2"
+pylint = "^3.3.1"
 
 [build-system]
 requires = ["poetry-core"]

{rapid_api_client-0.3.1 → rapid_api_client-0.3.2}/rapid_api_client/__init__.py

@@ -1,3 +1,7 @@
+"""
+rapid-api-client
+"""
+
 from importlib.metadata import version
 
 from .client import delete, get, http, patch, post, put

{rapid_api_client-0.3.1 → rapid_api_client-0.3.2}/rapid_api_client/client.py

@@ -1,3 +1,7 @@
+"""
+Decorator used to build the httpx request
+"""
+
 from dataclasses import dataclass, field
 from functools import partial, wraps
 from inspect import Signature, signature
@@ -18,7 +22,7 @@ from httpx import AsyncClient, Request, Response
 from pydantic import BaseModel, TypeAdapter
 from pydantic_xml import BaseXmlModel
 
-from .model import Body, FileBody, Header, Path, Query, RapidApi
+from .model import Body, CustomParameter, FileBody, Header, Path, Query, RapidApi
 from .utils import filter_none_values, find_annotation
 
 BM = TypeVar("BM", bound=BaseModel)
@@ -27,15 +31,23 @@ T = TypeVar("T")
 
 @dataclass
 class CustomParameters:
+    """
+    Class containing all custom parameters used to build the request.
+    """
+
     path: Dict[str, Path] = field(default_factory=dict)
     query: Dict[str, Query] = field(default_factory=dict)
     headers: Dict[str, Header] = field(default_factory=dict)
     body: Dict[str, Body] = field(default_factory=dict)
 
     @classmethod
-    def from_sig(cls, signature: Signature) -> Self:
+    def from_sig(cls, sig: Signature) -> Self:
+        """
+        Iterate over parameters of given function to find annotated parameters
+        """
         out = cls()
-        for parameter in signature.parameters.values():
+        for parameter in sig.parameters.values():
+            annot: CustomParameter | None = None
             if (annot := find_annotation(parameter, Path)) is not None:
                 out.path[parameter.name] = annot
             if (annot := find_annotation(parameter, Query)) is not None:
@@ -49,50 +61,60 @@ class CustomParameters:
 
 def build_request(
     client: AsyncClient,
-    signature: Signature,
+    sig: Signature,
     parameters: CustomParameters,
     method: str,
     path: str,
     args: Tuple[Any],
     kwargs: Mapping[str, Any],
+    timeout: float | None,
 ) -> Request:
+    """
+    Build the httpx request with given custom parameters.
+    """
     # valuate arguments with default values
-    ba = signature.bind(*args, **kwargs)
+    ba = sig.bind(*args, **kwargs)
     ba.apply_defaults()
 
     # resolve the api path
     path = path.format(**{k: ba.arguments[k] for k in parameters.path})
 
-    headers = filter_none_values(
+    build_kwargs: Dict[str, Any] = {}
+
+    build_kwargs["headers"] = filter_none_values(
         {
             annot.alias or param: ba.arguments[param]
             for param, annot in parameters.headers.items()
         }
     )
-    params = filter_none_values(
+    build_kwargs["params"] = filter_none_values(
         {
             annot.alias or param: ba.arguments[param]
             for param, annot in parameters.query.items()
         }
     )
-    content = None
-    files = {}
     for param, annot in parameters.body.items():
         if (value := ba.arguments[param]) is not None:
             if isinstance(annot, FileBody):
+                files = build_kwargs.setdefault("files", {})
                 files[annot.alias or param] = annot.serialize(value)
             else:
-                content = annot.serialize(value)
+                build_kwargs["content"] = annot.serialize(value)
 
-    return client.build_request(
-        method, path, headers=headers, params=params, content=content, files=files
-    )
+    # handle extra optional kwargs
+    if timeout is not None:
+        build_kwargs["timeout"] = timeout
+
+    return client.build_request(method, path, **build_kwargs)
 
 
 def handle_response(
     response: Response,
     response_class: Type[Response | str | bytes | BM] | TypeAdapter[T],
 ) -> Response | str | bytes | BM | T:
+    """
+    Parse the response given the expected class
+    """
     # do not check response status code if we return the Response itself
     if response_class is Response:
         return response
@@ -113,31 +135,46 @@ def handle_response(
 
 @overload
 def http(
-    method: str, path: str, response_class: Type[Response] = Response
+    method: str,
+    path: str,
+    response_class: Type[Response] = Response,
+    timeout: float | None = None,
 ) -> Callable[[Callable], Callable[..., Awaitable[Response]]]: ...
 
 
 @overload
 def http(
-    method: str, path: str, response_class: Type[str]
+    method: str,
+    path: str,
+    response_class: Type[str],
+    timeout: float | None = None,
 ) -> Callable[[Callable], Callable[..., Awaitable[str]]]: ...
 
 
 @overload
 def http(
-    method: str, path: str, response_class: Type[bytes]
+    method: str,
+    path: str,
+    response_class: Type[bytes],
+    timeout: float | None = None,
 ) -> Callable[[Callable], Callable[..., Awaitable[bytes]]]: ...
 
 
 @overload
 def http(
-    method: str, path: str, response_class: Type[BM]
+    method: str,
+    path: str,
+    response_class: Type[BM],
+    timeout: float | None = None,
 ) -> Callable[[Callable], Callable[..., Awaitable[BM]]]: ...
 
 
 @overload
 def http(
-    method: str, path: str, response_class: TypeAdapter[T]
+    method: str,
+    path: str,
+    response_class: TypeAdapter[T],
+    timeout: float | None = None,
 ) -> Callable[[Callable], Callable[..., Awaitable[T]]]: ...
 
 
@@ -145,7 +182,12 @@ def http(
     method: str,
     path: str,
     response_class: Type[BM | str | bytes | Response] | TypeAdapter[T] = Response,
+    timeout: float | None = None,
 ) -> Callable[[Callable], Callable[..., Awaitable[BM | str | bytes | Response | T]]]:
+    """
+    Main decorator used to generate an http request and return its result
+    """
+
     def decorator(
         func: Callable,
     ) -> Callable[..., Awaitable[BM | str | bytes | Response | T]]:
@@ -159,7 +201,7 @@ def http(
             ), f"{args[0]} should be an instance of RapidApi"
             client = args[0].client
             request = build_request(
-                client, sig, custom_parameters, method, path, args, kwargs
+                client, sig, custom_parameters, method, path, args, kwargs, timeout
             )
             response = await client.send(request)
             return handle_response(response, response_class)

{rapid_api_client-0.3.1 → rapid_api_client-0.3.2}/rapid_api_client/model.py

@@ -1,3 +1,7 @@
+"""
+Model classes
+"""
+
 from dataclasses import dataclass, field
 from typing import Any
 
@@ -12,50 +16,97 @@ except ImportError:  # pragma: nocover
 
 @dataclass
 class RapidApi:
+    """
+    Represent an API, a RapidApi subclass should have methods decorated with @http
+    which are endpoints
+    """
+
     client: AsyncClient = field(default_factory=AsyncClient)
 
 
-class CustomParameter: ...
+class CustomParameter:
+    """
+    Meta class for annotations used to customize the request build
+    """
 
 
-class Path(CustomParameter): ...
+class Path(CustomParameter):
+    """
+    Annotation to declare an argument used to resolve the api path/url
+    """
 
 
 @dataclass
 class Query(CustomParameter):
+    """
+    Annotation to declare an argument used as a query parameter
+    """
+
     alias: str | None = None
 
 
 @dataclass
 class Header(CustomParameter):
+    """
+    Annotation to declare an argument used as a request header
+    """
+
     alias: str | None = None
 
 
 class Body(CustomParameter):
+    """
+    Annotation to declare an argument used as http content for post/put/...
+    """
+
     def serialize(self, body: Any) -> str | bytes:
+        """
+        Serialize the annotated parameter value
+        """
         return body
 
 
 @dataclass
 class FileBody(Body):
+    """
+    Annotation to declare an argument used as file to be uploaded
+    """
+
     alias: str | None = None
 
     def serialize(self, body: Any) -> str | bytes:
+        """
+        Serialize the annotated parameter value
+        """
         return body
 
 
 @dataclass
 class PydanticBody(Body):
+    """
+    Annotation to declare an argument to be serialized to json and used as http content
+    """
+
     prettyprint: bool = False
 
     def serialize(self, body: Any) -> str | bytes:
+        """
+        Serialize the annotated parameter value
+        """
         assert isinstance(body, BaseModel)
         return body.model_dump_json(indent=2 if self.prettyprint else None)
 
 
 @dataclass
 class PydanticXmlBody(Body):
+    """
+    Annotation to declare an argument to be serialized to xml and used as http content
+    """
+
     def serialize(self, body: Any) -> str | bytes:
+        """
+        Serialize the annotated parameter value
+        """
         assert (
             pydantic_xml is not None
         ), "pydantic-xml must be installed to use PydanticXmlBody"

{rapid_api_client-0.3.1 → rapid_api_client-0.3.2}/rapid_api_client/utils.py

@@ -1,3 +1,7 @@
+"""
+Utility methods
+"""
+
 from inspect import Parameter
 from typing import Any, Dict, Type, TypeVar, get_args
 
@@ -7,10 +11,16 @@ CP = TypeVar("CP", bound=CustomParameter)
 
 
 def filter_none_values(values: Dict[str, Any | None]) -> Dict[str, Any]:
+    """
+    Return a new map with only key/value if the value is set.
+    """
     return {k: v for k, v in values.items() if v is not None}
 
 
 def find_annotation(param: Parameter, cls: Type[CP]) -> CP | None:
+    """
+    Check if the given parameter has an annotation which is or is a subclass of given type
+    """
     if param.annotation:
         for an in get_args(param.annotation):
             if isinstance(an, cls):