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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: rapid-api-client
-Version: 0.3.2
+Version: 0.3.4
 Summary: Rapidly develop your API clients using decorators and annotations
 Author: Sébastien MB
 Author-email: seb@essembeh.org
@@ -134,7 +134,7 @@ class MyApi(RapidApi)
 
     # this method return a httpx.Response
     @get("/user/me")
-    async def get_user_resp(self): ...
+    async def get_user_raw(self): ...
 
     # this method returns a User class
     @get("/user/me", response_class=User)
@@ -190,11 +190,11 @@ class MyApi(RapidApi)
 
     # Headers can have a default value
     @get("/issues")
-    async def get_issues(self, version: Annotated[str, Header()] = "1"): ...
+    async def get_issues_default(self, version: Annotated[str, Header()] = "1"): ...
 
     # Headers can have an alias to change the key in the http request
     @get("/issues")
-    async def get_issues(self, version: Annotated[str, Header(alias="X-API-Version")] = "1"): ...
+    async def get_issues_version(self, version: Annotated[str, Header(alias="X-API-Version")] = "1"): ...
 ```
 
 ## Body parameter
@@ -211,15 +211,15 @@ class MyApi(RapidApi)
 
     # send a string in request content
     @post("/string")
-    async def message(self, body: Annotated[str, Body()]): ...
+    async def post_string(self, body: Annotated[str, Body()]): ...
 
     # send a string in request content
     @post("/model")
-    async def model(self, body: Annotated[MyPydanticClass, PydanticBody()]): ...
+    async def post_model(self, body: Annotated[MyPydanticClass, PydanticBody()]): ...
 
     # send a multiple files
     @post("/files")
-    async def model(self, report: Annotated[bytes, FileBody()], image: Annotated[bytes, FileBody()]): ...
+    async def post_files(self, report: Annotated[bytes, FileBody()], image: Annotated[bytes, FileBody()]): ...
 
  ```
 

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

@@ -102,7 +102,7 @@ class MyApi(RapidApi)
 
     # this method return a httpx.Response
     @get("/user/me")
-    async def get_user_resp(self): ...
+    async def get_user_raw(self): ...
 
     # this method returns a User class
     @get("/user/me", response_class=User)
@@ -158,11 +158,11 @@ class MyApi(RapidApi)
 
     # Headers can have a default value
     @get("/issues")
-    async def get_issues(self, version: Annotated[str, Header()] = "1"): ...
+    async def get_issues_default(self, version: Annotated[str, Header()] = "1"): ...
 
     # Headers can have an alias to change the key in the http request
     @get("/issues")
-    async def get_issues(self, version: Annotated[str, Header(alias="X-API-Version")] = "1"): ...
+    async def get_issues_version(self, version: Annotated[str, Header(alias="X-API-Version")] = "1"): ...
 ```
 
 ## Body parameter
@@ -179,15 +179,15 @@ class MyApi(RapidApi)
 
     # send a string in request content
     @post("/string")
-    async def message(self, body: Annotated[str, Body()]): ...
+    async def post_string(self, body: Annotated[str, Body()]): ...
 
     # send a string in request content
     @post("/model")
-    async def model(self, body: Annotated[MyPydanticClass, PydanticBody()]): ...
+    async def post_model(self, body: Annotated[MyPydanticClass, PydanticBody()]): ...
 
     # send a multiple files
     @post("/files")
-    async def model(self, report: Annotated[bytes, FileBody()], image: Annotated[bytes, FileBody()]): ...
+    async def post_files(self, report: Annotated[bytes, FileBody()], image: Annotated[bytes, FileBody()]): ...
 
  ```
 

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

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "rapid-api-client"
-version = "0.3.2"
+version = "0.3.4"
 description = "Rapidly develop your API clients using decorators and annotations"
 authors = ["Sébastien MB <seb@essembeh.org>"]
 readme = "README.md"

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

@@ -4,8 +4,9 @@ rapid-api-client
 
 from importlib.metadata import version
 
-from .client import delete, get, http, patch, post, put
-from .model import Body, FileBody, Header, Path, PydanticBody, Query, RapidApi
+from .annotations import Body, FileBody, Header, Path, PydanticBody, Query
+from .client import RapidApi
+from .decorator import delete, get, http, patch, post, put
 
 __version__ = version(__name__)
 __all__ = [

rapid_api_client-0.3.2/rapid_api_client/model.py → rapid_api_client-0.3.4/rapid_api_client/annotations.py

@@ -2,10 +2,9 @@
 Model classes
 """
 
-from dataclasses import dataclass, field
-from typing import Any
+from dataclasses import dataclass
+from typing import Any, Literal
 
-from httpx import AsyncClient
 from pydantic import BaseModel
 
 try:
@@ -14,30 +13,20 @@ except ImportError:  # pragma: nocover
     pydantic_xml = None  # type: ignore
 
 
-@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 BaseAnnotation:
     """
     Meta class for annotations used to customize the request build
     """
 
 
-class Path(CustomParameter):
+class Path(BaseAnnotation):
     """
     Annotation to declare an argument used to resolve the api path/url
     """
 
 
 @dataclass
-class Query(CustomParameter):
+class Query(BaseAnnotation):
     """
     Annotation to declare an argument used as a query parameter
     """
@@ -46,7 +35,7 @@ class Query(CustomParameter):
 
 
 @dataclass
-class Header(CustomParameter):
+class Header(BaseAnnotation):
     """
     Annotation to declare an argument used as a request header
     """
@@ -54,11 +43,14 @@ class Header(CustomParameter):
     alias: str | None = None
 
 
-class Body(CustomParameter):
+@dataclass
+class Body(BaseAnnotation):
     """
     Annotation to declare an argument used as http content for post/put/...
     """
 
+    target: Literal["content", "data", "files"] = "content"
+
     def serialize(self, body: Any) -> str | bytes:
         """
         Serialize the annotated parameter value
@@ -72,14 +64,9 @@ class FileBody(Body):
     Annotation to declare an argument used as file to be uploaded
     """
 
+    target: Literal["content", "data", "files"] = "files"
     alias: str | None = None
 
-    def serialize(self, body: Any) -> str | bytes:
-        """
-        Serialize the annotated parameter value
-        """
-        return body
-
 
 @dataclass
 class PydanticBody(Body):

rapid_api_client-0.3.4/rapid_api_client/client.py

@@ -0,0 +1,138 @@
+"""
+Decorator used to build the httpx request
+"""
+
+from dataclasses import dataclass, field
+from inspect import Signature
+from typing import (
+    Any,
+    Dict,
+    Mapping,
+    Self,
+    Tuple,
+    Type,
+    TypeVar,
+)
+
+from httpx import AsyncClient, Request, Response
+from pydantic import BaseModel, TypeAdapter
+from pydantic_xml import BaseXmlModel
+
+from .annotations import BaseAnnotation, Body, FileBody, Header, Path, Query
+from .utils import filter_none_values, find_annotation
+
+BM = TypeVar("BM", bound=BaseModel)
+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, sig: Signature) -> Self:
+        """
+        Iterate over parameters of given function to find annotated parameters
+        """
+        out = cls()
+        for parameter in sig.parameters.values():
+            annot: BaseAnnotation | 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:
+                out.query[parameter.name] = annot
+            if (annot := find_annotation(parameter, Header)) is not None:
+                out.headers[parameter.name] = annot
+            if (annot := find_annotation(parameter, Body)) is not None:
+                out.body[parameter.name] = annot
+        return out
+
+
+@dataclass
+class RapidApi:
+    """
+    Represent an API, a RapidApi subclass should have methods decorated with @http
+    which are endpoints
+    """
+
+    client: AsyncClient = field(default_factory=AsyncClient)
+
+    def _build_request(
+        self,
+        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 = sig.bind(*args, **kwargs)
+        ba.apply_defaults()
+
+        # resolve the api path
+        path = path.format(**{k: ba.arguments[k] for k in parameters.path})
+
+        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()
+            }
+        )
+        build_kwargs["params"] = filter_none_values(
+            {
+                annot.alias or param: ba.arguments[param]
+                for param, annot in parameters.query.items()
+            }
+        )
+        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:
+                    build_kwargs[annot.target] = annot.serialize(value)
+
+        # handle extra optional kwargs
+        if timeout is not None:
+            build_kwargs["timeout"] = timeout
+
+        return self.client.build_request(method, path, **build_kwargs)
+
+    def _handle_response(
+        self,
+        response: Response,
+        response_class: Type[Response | str | bytes | BM] | TypeAdapter[T] = Response,
+    ) -> 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
+        # before parsing the response, check its status
+        response.raise_for_status()
+        if response_class is str:
+            return response.text
+        if response_class is bytes:
+            return response.content
+        if isinstance(response_class, TypeAdapter):
+            return response_class.validate_json(response.content)
+        if issubclass(response_class, BaseXmlModel):
+            return response_class.from_xml(response.content)
+        if issubclass(response_class, BaseModel):
+            return response_class.model_validate_json(response.content)
+        raise ValueError(f"Response class not supported: {response_class}")

rapid_api_client-0.3.4/rapid_api_client/decorator.py

@@ -0,0 +1,103 @@
+"""
+Decorator used to build the request and send it with httpx
+"""
+
+from functools import partial, wraps
+from inspect import signature
+from typing import (
+    Any,
+    Callable,
+    Coroutine,
+    Type,
+    overload,
+)
+
+from httpx import Response
+from pydantic import TypeAdapter
+
+from .client import BM, CustomParameters, RapidApi, T
+
+
+@overload
+def http(
+    method: str,
+    path: str,
+    response_class: Type[Response] = Response,
+    timeout: float | None = None,
+) -> Callable[[Callable], Callable[..., Coroutine[Any, Any, Response]]]: ...
+
+
+@overload
+def http(
+    method: str,
+    path: str,
+    response_class: Type[str],
+    timeout: float | None = None,
+) -> Callable[[Callable], Callable[..., Coroutine[Any, Any, str]]]: ...
+
+
+@overload
+def http(
+    method: str,
+    path: str,
+    response_class: Type[bytes],
+    timeout: float | None = None,
+) -> Callable[[Callable], Callable[..., Coroutine[Any, Any, bytes]]]: ...
+
+
+@overload
+def http(
+    method: str,
+    path: str,
+    response_class: Type[BM],
+    timeout: float | None = None,
+) -> Callable[[Callable], Callable[..., Coroutine[Any, Any, BM]]]: ...
+
+
+@overload
+def http(
+    method: str,
+    path: str,
+    response_class: TypeAdapter[T],
+    timeout: float | None = None,
+) -> Callable[[Callable], Callable[..., Coroutine[Any, Any, T]]]: ...
+
+
+def http(
+    method: str,
+    path: str,
+    response_class: Type[BM | str | bytes | Response] | TypeAdapter[T] = Response,
+    timeout: float | None = None,
+) -> Callable[
+    [Callable], Callable[..., Coroutine[Any, Any, BM | str | bytes | Response | T]]
+]:
+    """
+    Main decorator used to generate an http request and return its result
+    """
+
+    def decorator(
+        func: Callable,
+    ) -> Callable[..., Coroutine[Any, Any, BM | str | bytes | Response | T]]:
+        sig = signature(func)
+        custom_parameters = CustomParameters.from_sig(sig)
+
+        @wraps(func)
+        async def wrapper(*args, **kwargs) -> BM | str | bytes | Response | T:
+            if not isinstance((api := args[0]), RapidApi):
+                raise ValueError(f"{api} should be an instance of RapidApi")
+            request = api._build_request(
+                sig, custom_parameters, method, path, args, kwargs, timeout
+            )
+            response = await api.client.send(request)
+            return api._handle_response(response, response_class=response_class)
+
+        return wrapper
+
+    return decorator
+
+
+get = partial(http, "GET")
+post = partial(http, "POST")
+delete = partial(http, "DELETE")
+put = partial(http, "PUT")
+patch = partial(http, "PATCH")

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

@@ -5,9 +5,9 @@ Utility methods
 from inspect import Parameter
 from typing import Any, Dict, Type, TypeVar, get_args
 
-from rapid_api_client.model import CustomParameter
+from .annotations import BaseAnnotation
 
-CP = TypeVar("CP", bound=CustomParameter)
+BA = TypeVar("BA", bound=BaseAnnotation)
 
 
 def filter_none_values(values: Dict[str, Any | None]) -> Dict[str, Any]:
@@ -17,7 +17,7 @@ def filter_none_values(values: Dict[str, Any | None]) -> Dict[str, Any]:
     return {k: v for k, v in values.items() if v is not None}
 
 
-def find_annotation(param: Parameter, cls: Type[CP]) -> CP | None:
+def find_annotation(param: Parameter, cls: Type[BA]) -> BA | None:
     """
     Check if the given parameter has an annotation which is or is a subclass of given type
     """

rapid_api_client-0.3.2/rapid_api_client/client.py

@@ -1,218 +0,0 @@
-"""
-Decorator used to build the httpx request
-"""
-
-from dataclasses import dataclass, field
-from functools import partial, wraps
-from inspect import Signature, signature
-from typing import (
-    Any,
-    Awaitable,
-    Callable,
-    Dict,
-    Mapping,
-    Self,
-    Tuple,
-    Type,
-    TypeVar,
-    overload,
-)
-
-from httpx import AsyncClient, Request, Response
-from pydantic import BaseModel, TypeAdapter
-from pydantic_xml import BaseXmlModel
-
-from .model import Body, CustomParameter, FileBody, Header, Path, Query, RapidApi
-from .utils import filter_none_values, find_annotation
-
-BM = TypeVar("BM", bound=BaseModel)
-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, sig: Signature) -> Self:
-        """
-        Iterate over parameters of given function to find annotated parameters
-        """
-        out = cls()
-        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:
-                out.query[parameter.name] = annot
-            if (annot := find_annotation(parameter, Header)) is not None:
-                out.headers[parameter.name] = annot
-            if (annot := find_annotation(parameter, Body)) is not None:
-                out.body[parameter.name] = annot
-        return out
-
-
-def build_request(
-    client: AsyncClient,
-    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 = sig.bind(*args, **kwargs)
-    ba.apply_defaults()
-
-    # resolve the api path
-    path = path.format(**{k: ba.arguments[k] for k in parameters.path})
-
-    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()
-        }
-    )
-    build_kwargs["params"] = filter_none_values(
-        {
-            annot.alias or param: ba.arguments[param]
-            for param, annot in parameters.query.items()
-        }
-    )
-    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:
-                build_kwargs["content"] = annot.serialize(value)
-
-    # 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
-    # before parsing the response, check its status
-    response.raise_for_status()
-    if response_class is str:
-        return response.text
-    if response_class is bytes:
-        return response.content
-    if isinstance(response_class, TypeAdapter):
-        return response_class.validate_json(response.content)
-    if issubclass(response_class, BaseXmlModel):
-        return response_class.from_xml(response.content)
-    if issubclass(response_class, BaseModel):
-        return response_class.model_validate_json(response.content)
-    raise ValueError(f"Response class not supported: {response_class}")
-
-
-@overload
-def http(
-    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],
-    timeout: float | None = None,
-) -> Callable[[Callable], Callable[..., Awaitable[str]]]: ...
-
-
-@overload
-def http(
-    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],
-    timeout: float | None = None,
-) -> Callable[[Callable], Callable[..., Awaitable[BM]]]: ...
-
-
-@overload
-def http(
-    method: str,
-    path: str,
-    response_class: TypeAdapter[T],
-    timeout: float | None = None,
-) -> Callable[[Callable], Callable[..., Awaitable[T]]]: ...
-
-
-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]]:
-        sig = signature(func)
-        custom_parameters = CustomParameters.from_sig(sig)
-
-        @wraps(func)
-        async def wrapper(*args, **kwargs) -> BM | str | bytes | Response | T:
-            assert isinstance(
-                args[0], RapidApi
-            ), f"{args[0]} should be an instance of RapidApi"
-            client = args[0].client
-            request = build_request(
-                client, sig, custom_parameters, method, path, args, kwargs, timeout
-            )
-            response = await client.send(request)
-            return handle_response(response, response_class)
-
-        return wrapper
-
-    return decorator
-
-
-get = partial(http, "GET")
-post = partial(http, "POST")
-delete = partial(http, "DELETE")
-put = partial(http, "PUT")
-patch = partial(http, "PATCH")