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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: rapid-api-client
-Version: 0.7.0
+Version: 0.7.2
 Summary: Rapidly develop your API clients using decorators and annotations
 Author: Sébastien MB
 Author-email: seb@essembeh.org
@@ -37,20 +37,20 @@ Description-Content-Type: text/markdown
 ![Github](https://img.shields.io/github/tag/essembeh/rapid-api-client.svg)
 ![PyPi](https://img.shields.io/pypi/v/rapid-api-client.svg)
 ![Python](https://img.shields.io/pypi/pyversions/rapid-api-client.svg)
-![CI](https://github.com/essembeh/python-helloworld/actions/workflows/poetry.yml/badge.svg)
+![CI](https://github.com/essembeh/rapid-api-client/actions/workflows/poetry.yml/badge.svg)
 
-> 🙏 As a Python Backend developer, I've wasted so much time in recent years writing the same API clients over and over using [Requests](https://requests.readthedocs.io/) or [HTTPX](https://www.python-httpx.org/); At the same time, I could be so efficient by using [FastAPI](https://fastapi.tiangolo.com/) for API servers; I just wanted to save time for my upcoming projects, thinking that other developers might find it useful too.
+> 🙏 As a Python Backend developer, I've wasted so much time in recent years writing the same API clients over and over using [Requests](https://requests.readthedocs.io/) or [HTTPX](https://www.python-httpx.org/). At the same time, I could be so efficient by using [FastAPI](https://fastapi.tiangolo.com/) for API servers. I just wanted to save time for my upcoming projects, thinking that other developers might find it useful too.
 
-# Rapid Api Client
+# Rapid API Client
 
 Library to **rapidly** develop *API clients* in Python, based on [Pydantic](https://docs.pydantic.dev/) and [Httpx](https://www.python-httpx.org/), using almost only *decorators* and *annotations*.
 
 ✨ Main features:
 - ✏️ You don't write any code, you only declare the endpoints using *decorators* and *annotations*.
 - 🪄 Pydantic validation for `Header`, `Query`, `Path` or `Body` parameters.
-- 📤 Support Pydantic to parse and validate reponses content so your method returns a model object if the response is OK.
-- 📥 Also support Pydantic serialization for `Body` with `POST`-like opeations.
-- 🏗️ Does not reimplement any low-level http related logic (like auth, transport ...), it simply uses `httpx.Client` like you are used to, *decorators* simply build the `httpx.Request` for you.
+- 📤 Support Pydantic to parse and validate responses content so your method returns a model object if the response is OK.
+- 📥 Also support Pydantic serialization for `Body` with `POST`-like operations.
+- 🏗️ Does not reimplement any low-level HTTP related logic (like auth, transport...), it simply uses `httpx.Client` like you are used to. *Decorators* simply build the `httpx.Request` for you.
 - ⚡️ Support `async` operations, with `httpx.AsyncClient`.
 
 
@@ -74,7 +74,7 @@ Then, declare your API client using *decorators* and *annotations*:
 ```python
 from typing import Annotated, List
 from pydantic import BaseModel
-from rapid_api_client import RapidApi, get, post, Path, Query, JsonBody
+from rapid_api_client import RapidApi, get, post, Path, Query, JsonBody, rapid
 
 # Define your data models
 class User(BaseModel):
@@ -87,6 +87,8 @@ class CreateUserRequest(BaseModel):
     email: str
 
 # Define your API client
+# Note: the @rapid decorator is optional, but it allows you to set default values for your constructor
+@rapid(base_url="https://api.example.com")
 class UserApi(RapidApi):
     # GET request with path parameter and query parameter
     @get("/users/{user_id}")
@@ -115,7 +117,8 @@ Finally, use your API client to interact with the API:
 # Use the API client
 if __name__ == "__main__":
     # Initialize the API client
-    api = UserApi(base_url="https://api.example.com")
+    # Note: you don't need to pass the base URL here if you used the @rapid decorator
+    api = UserApi()
     
     # Get a user by ID
     user = api.get_user(123)
@@ -135,9 +138,9 @@ if __name__ == "__main__":
 
 # Features
 
-## Http methods
+## HTTP Methods
 
-Any HTTP method can be used with `http` decorator
+Any HTTP method can be used with the `http` decorator:
 
 ```python
 from rapid_api_client import RapidApi, http 
@@ -155,7 +158,7 @@ class MyApi(RapidApi):
     def delete(self): ...
 ```
 
-Convenient decorators are available like `get`, `post`, `delete`, `put`, `patch`
+Convenient decorators are available like `get`, `post`, `delete`, `put`, `patch`:
 
 ```python
 from rapid_api_client import RapidApi, get, post, delete
@@ -172,7 +175,7 @@ class MyApi(RapidApi):
     def delete(self): ...
 ```
 
-To use you API, you just need to instanciate it with a `httpx.Client` like:
+To use your API, you just need to instantiate it with a `httpx.Client` like:
 
 ```python
 from httpx import Client
@@ -183,12 +186,12 @@ resp.raise_for_status()
 ```
 
 
-## `async` support
+## `async` Support
 
 > ✨ Since version `0.7.0`, the same code works for synchronous and `async` methods.
 
 You can write:
-```py
+```python
 class GithubIssuesApi(RapidApi):
 
     @get("/repos/{owner}/{repo}/issues")
@@ -204,35 +207,38 @@ issues_async = await api.alist_issues("essembeh", "rapid-api-client", state="clo
 # both lists are the same
 ```
 
-*RapidApiClient* support both `sync` and `async` methods, it will automatically choose `httpx.Client` or `httpx.AsyncClient` to build and send the HTTP request.
+*Rapid API Client* supports both `sync` and `async` methods. It will automatically choose `httpx.Client` or `httpx.AsyncClient` to build and send the HTTP request.
 
-By default, all parameters given to `RapidApi` contructor are used to instanciate a `httpx.Client` or `httpx.AsyncClient`, depending if your method is `async` or not, but you can provide a custom `client` or `async_client` (or both) to have more control on the clients creation.
+By default, all parameters given to the `RapidApi` constructor are used to instantiate a `httpx.Client` or `httpx.AsyncClient`, depending on whether your method is `async` or not. You can provide a custom `client` or `async_client` (or both) to have more control over the clients creation:
 
-```py
+```python
 from httpx import Client, AsyncClient
 
-# in this example, the sync client has a timeout of 10s and the async client has a timeout of 20s
-api = GithubIssuesApi(client=Client(base_url="https://api.github.com", timeout=10), async_client=AsyncClient(base_url="https://api.github.com", timeout=20))
+# In this example, the sync client has a timeout of 10s and the async client has a timeout of 20s
+api = GithubIssuesApi(
+    client=Client(base_url="https://api.github.com", timeout=10), 
+    async_client=AsyncClient(base_url="https://api.github.com", timeout=20)
+)
 
-issues_sync = api.list_issues("essembeh", "rapid-api-client", state="closed") # this http call has a timeout of 10s
-issues_async = await api.alist_issues("essembeh", "rapid-api-client", state="closed") # this one has a timeout of 20s
+issues_sync = api.list_issues("essembeh", "rapid-api-client", state="closed")  # this HTTP call has a timeout of 10s
+issues_async = await api.alist_issues("essembeh", "rapid-api-client", state="closed")  # this one has a timeout of 20s
 ```
 
 
 
-## Response parsing
+## Response Parsing
 
-By default methods return a `httpx.Response` object and the http return code is not tested (you have to call `resp.raise_for_status()` if you need to ensure the response is OK).
+By default, methods return a `httpx.Response` object and the HTTP return code is not tested (you have to call `resp.raise_for_status()` if you need to ensure the response is OK).
 
-But you can also specify a class so that the response is parsed, you can use:
+But you can also specify a class so that the response is parsed. You can use:
 - `httpx.Response` to get the response itself, this is the default behavior
 - `str` to get the `response.text` 
 - `bytes` to get the `response.content` 
-- Any *Pydantic* model class (subclass of `BaseModel`), the *json* will be automatically validated
-- Any *Pydantic-xml* model class (subclass of `BaseXmlModel`), the *xml* will be automatically validated
-- Any other class will try to use `TypeAdapter` to parse it (see [pydantic doc](https://docs.pydantic.dev/latest/api/type_adapter/)
+- Any *Pydantic* model class (subclass of `BaseModel`), the *JSON* will be automatically validated
+- Any *Pydantic-xml* model class (subclass of `BaseXmlModel`), the *XML* will be automatically validated
+- Any other class will try to use `TypeAdapter` to parse it (see [pydantic doc](https://docs.pydantic.dev/latest/api/type_adapter/))
 
-> Note: When the returned object is not `httpx.Response`, the `raise_for_status()` is called to ensure the http response is OK before parsing the content, you can disable this behavior by setting `raise_for_status=False` in the method decorator.
+> Note: When the returned object is not `httpx.Response`, the `raise_for_status()` is called to ensure the HTTP response is OK before parsing the content. You can disable this behavior by setting `raise_for_status=False` in the method decorator.
 
 ```python
 class User(BaseModel):
@@ -241,7 +247,7 @@ class User(BaseModel):
 
 class MyApi(RapidApi):
 
-    # This method return a httpx.Response, you can omit it, but you should add it for clarity
+    # This method returns a httpx.Response, you can omit it, but you should add it for clarity
     @get("/user/me")
     def get_user_raw(self) -> Response: ...
 
@@ -251,9 +257,9 @@ class MyApi(RapidApi):
 ```
 
 
-## Path parameters
+## Path Parameters
 
-Like `fastapi` you can use your method arguments to build the api path to call.
+Like `fastapi`, you can use your method arguments to build the API path to call:
 
 ```python
 class MyApi(RapidApi):
@@ -273,12 +279,11 @@ class MyApi(RapidApi):
     # Path parameters with a default value using a factory
     @get("/user/{user_id}")
     def get_user(self, user_id: Annotated[int, Path(default_factory=lambda: 42)]): ...
-
 ```
 
-## Query parameters
+## Query Parameters
 
-You can add `query parameters` to your request using the `Query` annotation.
+You can add `query parameters` to your request using the `Query` annotation:
 
 ```python
 class MyApi(RapidApi):
@@ -299,15 +304,15 @@ class MyApi(RapidApi):
     @get("/issues")
     def get_issues(self, sort: Annotated[str, Query(default_factory=lambda: "updated")]): ...
 
-    # Query parameter with a default value
+    # Query parameter with an alias
     @get("/issues")
     def get_issues(self, my_parameter: Annotated[str, Query(alias="sort")]): ...
 ```
 
 
-## Header parameter
+## Header Parameters
 
-You can add `headers` to your request using the `Header` annotation.
+You can add `headers` to your request using the `Header` annotation:
 
 ```python
 class MyApi(RapidApi):
@@ -328,7 +333,7 @@ class MyApi(RapidApi):
     @get("/issues")
     def get_issues(self, x_version: Annotated[str, Header(default_factory=lambda: "2024.06")]): ...
 
-    # Header parameter with a default value
+    # Header parameter with an alias
     @get("/issues")
     def get_issues(self, my_parameter: Annotated[str, Header(alias="x-version")]): ...
 
@@ -337,61 +342,59 @@ class MyApi(RapidApi):
     def get_issues(self): ...
 ```
 
-## Body parameter
+## Body Parameters
 
 You can send a body with your request using the `Body` annotation. 
 
-This body can be 
- - a *raw* object with `Body`
- - a `dict` object with `JsonBody` 
- - a *Pydantic* object  with `PydanticBody`
- - one or more files with `FileBody`
+This body can be:
+ - A *raw* object with `Body`
+ - A `dict` object with `JsonBody` 
+ - A *Pydantic* object with `PydanticBody`
+ - One or more files with `FileBody`
 
- ```python
+```python
 class MyApi(RapidApi):
 
-    # send a string in request content
+    # Send a string in request content
     @post("/string")
     def post_string(self, body: Annotated[str, Body()]): ...
 
-    # send a dict in request content as json
+    # Send a dict in request content as JSON
     @post("/string")
     def post_json(self, body: Annotated[dict, JsonBody()]): ...
 
-    # send a Pydantic model in serialized as json
+    # Send a Pydantic model serialized as JSON
     @post("/model")
     def post_model(self, body: Annotated[MyPydanticClass, PydanticBody()]): ...
 
-    # send a multiple files
+    # Send multiple files
     @post("/files")
     def post_files(self, report: Annotated[bytes, FileBody()], image: Annotated[bytes, FileBody()]): ...
 
-    # send a form
+    # Send a form
     @post("/form")
     def post_form(self, my_param: Annotated[str, FormBody(alias="name")], extra_fields: Annotated[Dict[str, str], FormBody()]): ...
+```
 
- ```
-
- ## Xml Support
+## XML Support
 
- Xml is also supported is you use [Pydantic-Xml](https://pydantic-xml.readthedocs.io/), either for responses (if you type your function to return a `BaseXmlModel` subclass) or for POST/PUT content with `PydanticXmlBody`.
+XML is also supported if you use [Pydantic-Xml](https://pydantic-xml.readthedocs.io/), either for responses (if you type your function to return a `BaseXmlModel` subclass) or for POST/PUT content with `PydanticXmlBody`.
 
- ```python
+```python
 class ResponseXmlRootModel(BaseXmlModel): ...
 
 class MyApi(RapidApi):
 
-    # parse response xml content
+    # Parse response XML content
     @get("/get")
     def get_xml(self) -> ResponseXmlRootModel: ...
 
-    # serialize xml model automatically
+    # Serialize XML model automatically
     @post("/post")
     def post_xml(self, body: Annotated[ResponseXmlRootModel, PydanticXmlBody()]): ...
+```
 
- ```
-
- # Examples
+# Examples
 
 ## Authentication and Error Handling
 
@@ -460,5 +463,5 @@ if __name__ == "__main__":
     main()
 ```
 
-See [example directory](./examples/) for more examples
+See the [examples directory](./examples/) for more examples.
 

{rapid_api_client-0.7.0 → rapid_api_client-0.7.2}/README.md

@@ -1,20 +1,20 @@
 ![Github](https://img.shields.io/github/tag/essembeh/rapid-api-client.svg)
 ![PyPi](https://img.shields.io/pypi/v/rapid-api-client.svg)
 ![Python](https://img.shields.io/pypi/pyversions/rapid-api-client.svg)
-![CI](https://github.com/essembeh/python-helloworld/actions/workflows/poetry.yml/badge.svg)
+![CI](https://github.com/essembeh/rapid-api-client/actions/workflows/poetry.yml/badge.svg)
 
-> 🙏 As a Python Backend developer, I've wasted so much time in recent years writing the same API clients over and over using [Requests](https://requests.readthedocs.io/) or [HTTPX](https://www.python-httpx.org/); At the same time, I could be so efficient by using [FastAPI](https://fastapi.tiangolo.com/) for API servers; I just wanted to save time for my upcoming projects, thinking that other developers might find it useful too.
+> 🙏 As a Python Backend developer, I've wasted so much time in recent years writing the same API clients over and over using [Requests](https://requests.readthedocs.io/) or [HTTPX](https://www.python-httpx.org/). At the same time, I could be so efficient by using [FastAPI](https://fastapi.tiangolo.com/) for API servers. I just wanted to save time for my upcoming projects, thinking that other developers might find it useful too.
 
-# Rapid Api Client
+# Rapid API Client
 
 Library to **rapidly** develop *API clients* in Python, based on [Pydantic](https://docs.pydantic.dev/) and [Httpx](https://www.python-httpx.org/), using almost only *decorators* and *annotations*.
 
 ✨ Main features:
 - ✏️ You don't write any code, you only declare the endpoints using *decorators* and *annotations*.
 - 🪄 Pydantic validation for `Header`, `Query`, `Path` or `Body` parameters.
-- 📤 Support Pydantic to parse and validate reponses content so your method returns a model object if the response is OK.
-- 📥 Also support Pydantic serialization for `Body` with `POST`-like opeations.
-- 🏗️ Does not reimplement any low-level http related logic (like auth, transport ...), it simply uses `httpx.Client` like you are used to, *decorators* simply build the `httpx.Request` for you.
+- 📤 Support Pydantic to parse and validate responses content so your method returns a model object if the response is OK.
+- 📥 Also support Pydantic serialization for `Body` with `POST`-like operations.
+- 🏗️ Does not reimplement any low-level HTTP related logic (like auth, transport...), it simply uses `httpx.Client` like you are used to. *Decorators* simply build the `httpx.Request` for you.
 - ⚡️ Support `async` operations, with `httpx.AsyncClient`.
 
 
@@ -38,7 +38,7 @@ Then, declare your API client using *decorators* and *annotations*:
 ```python
 from typing import Annotated, List
 from pydantic import BaseModel
-from rapid_api_client import RapidApi, get, post, Path, Query, JsonBody
+from rapid_api_client import RapidApi, get, post, Path, Query, JsonBody, rapid
 
 # Define your data models
 class User(BaseModel):
@@ -51,6 +51,8 @@ class CreateUserRequest(BaseModel):
     email: str
 
 # Define your API client
+# Note: the @rapid decorator is optional, but it allows you to set default values for your constructor
+@rapid(base_url="https://api.example.com")
 class UserApi(RapidApi):
     # GET request with path parameter and query parameter
     @get("/users/{user_id}")
@@ -79,7 +81,8 @@ Finally, use your API client to interact with the API:
 # Use the API client
 if __name__ == "__main__":
     # Initialize the API client
-    api = UserApi(base_url="https://api.example.com")
+    # Note: you don't need to pass the base URL here if you used the @rapid decorator
+    api = UserApi()
     
     # Get a user by ID
     user = api.get_user(123)
@@ -99,9 +102,9 @@ if __name__ == "__main__":
 
 # Features
 
-## Http methods
+## HTTP Methods
 
-Any HTTP method can be used with `http` decorator
+Any HTTP method can be used with the `http` decorator:
 
 ```python
 from rapid_api_client import RapidApi, http 
@@ -119,7 +122,7 @@ class MyApi(RapidApi):
     def delete(self): ...
 ```
 
-Convenient decorators are available like `get`, `post`, `delete`, `put`, `patch`
+Convenient decorators are available like `get`, `post`, `delete`, `put`, `patch`:
 
 ```python
 from rapid_api_client import RapidApi, get, post, delete
@@ -136,7 +139,7 @@ class MyApi(RapidApi):
     def delete(self): ...
 ```
 
-To use you API, you just need to instanciate it with a `httpx.Client` like:
+To use your API, you just need to instantiate it with a `httpx.Client` like:
 
 ```python
 from httpx import Client
@@ -147,12 +150,12 @@ resp.raise_for_status()
 ```
 
 
-## `async` support
+## `async` Support
 
 > ✨ Since version `0.7.0`, the same code works for synchronous and `async` methods.
 
 You can write:
-```py
+```python
 class GithubIssuesApi(RapidApi):
 
     @get("/repos/{owner}/{repo}/issues")
@@ -168,35 +171,38 @@ issues_async = await api.alist_issues("essembeh", "rapid-api-client", state="clo
 # both lists are the same
 ```
 
-*RapidApiClient* support both `sync` and `async` methods, it will automatically choose `httpx.Client` or `httpx.AsyncClient` to build and send the HTTP request.
+*Rapid API Client* supports both `sync` and `async` methods. It will automatically choose `httpx.Client` or `httpx.AsyncClient` to build and send the HTTP request.
 
-By default, all parameters given to `RapidApi` contructor are used to instanciate a `httpx.Client` or `httpx.AsyncClient`, depending if your method is `async` or not, but you can provide a custom `client` or `async_client` (or both) to have more control on the clients creation.
+By default, all parameters given to the `RapidApi` constructor are used to instantiate a `httpx.Client` or `httpx.AsyncClient`, depending on whether your method is `async` or not. You can provide a custom `client` or `async_client` (or both) to have more control over the clients creation:
 
-```py
+```python
 from httpx import Client, AsyncClient
 
-# in this example, the sync client has a timeout of 10s and the async client has a timeout of 20s
-api = GithubIssuesApi(client=Client(base_url="https://api.github.com", timeout=10), async_client=AsyncClient(base_url="https://api.github.com", timeout=20))
+# In this example, the sync client has a timeout of 10s and the async client has a timeout of 20s
+api = GithubIssuesApi(
+    client=Client(base_url="https://api.github.com", timeout=10), 
+    async_client=AsyncClient(base_url="https://api.github.com", timeout=20)
+)
 
-issues_sync = api.list_issues("essembeh", "rapid-api-client", state="closed") # this http call has a timeout of 10s
-issues_async = await api.alist_issues("essembeh", "rapid-api-client", state="closed") # this one has a timeout of 20s
+issues_sync = api.list_issues("essembeh", "rapid-api-client", state="closed")  # this HTTP call has a timeout of 10s
+issues_async = await api.alist_issues("essembeh", "rapid-api-client", state="closed")  # this one has a timeout of 20s
 ```
 
 
 
-## Response parsing
+## Response Parsing
 
-By default methods return a `httpx.Response` object and the http return code is not tested (you have to call `resp.raise_for_status()` if you need to ensure the response is OK).
+By default, methods return a `httpx.Response` object and the HTTP return code is not tested (you have to call `resp.raise_for_status()` if you need to ensure the response is OK).
 
-But you can also specify a class so that the response is parsed, you can use:
+But you can also specify a class so that the response is parsed. You can use:
 - `httpx.Response` to get the response itself, this is the default behavior
 - `str` to get the `response.text` 
 - `bytes` to get the `response.content` 
-- Any *Pydantic* model class (subclass of `BaseModel`), the *json* will be automatically validated
-- Any *Pydantic-xml* model class (subclass of `BaseXmlModel`), the *xml* will be automatically validated
-- Any other class will try to use `TypeAdapter` to parse it (see [pydantic doc](https://docs.pydantic.dev/latest/api/type_adapter/)
+- Any *Pydantic* model class (subclass of `BaseModel`), the *JSON* will be automatically validated
+- Any *Pydantic-xml* model class (subclass of `BaseXmlModel`), the *XML* will be automatically validated
+- Any other class will try to use `TypeAdapter` to parse it (see [pydantic doc](https://docs.pydantic.dev/latest/api/type_adapter/))
 
-> Note: When the returned object is not `httpx.Response`, the `raise_for_status()` is called to ensure the http response is OK before parsing the content, you can disable this behavior by setting `raise_for_status=False` in the method decorator.
+> Note: When the returned object is not `httpx.Response`, the `raise_for_status()` is called to ensure the HTTP response is OK before parsing the content. You can disable this behavior by setting `raise_for_status=False` in the method decorator.
 
 ```python
 class User(BaseModel):
@@ -205,7 +211,7 @@ class User(BaseModel):
 
 class MyApi(RapidApi):
 
-    # This method return a httpx.Response, you can omit it, but you should add it for clarity
+    # This method returns a httpx.Response, you can omit it, but you should add it for clarity
     @get("/user/me")
     def get_user_raw(self) -> Response: ...
 
@@ -215,9 +221,9 @@ class MyApi(RapidApi):
 ```
 
 
-## Path parameters
+## Path Parameters
 
-Like `fastapi` you can use your method arguments to build the api path to call.
+Like `fastapi`, you can use your method arguments to build the API path to call:
 
 ```python
 class MyApi(RapidApi):
@@ -237,12 +243,11 @@ class MyApi(RapidApi):
     # Path parameters with a default value using a factory
     @get("/user/{user_id}")
     def get_user(self, user_id: Annotated[int, Path(default_factory=lambda: 42)]): ...
-
 ```
 
-## Query parameters
+## Query Parameters
 
-You can add `query parameters` to your request using the `Query` annotation.
+You can add `query parameters` to your request using the `Query` annotation:
 
 ```python
 class MyApi(RapidApi):
@@ -263,15 +268,15 @@ class MyApi(RapidApi):
     @get("/issues")
     def get_issues(self, sort: Annotated[str, Query(default_factory=lambda: "updated")]): ...
 
-    # Query parameter with a default value
+    # Query parameter with an alias
     @get("/issues")
     def get_issues(self, my_parameter: Annotated[str, Query(alias="sort")]): ...
 ```
 
 
-## Header parameter
+## Header Parameters
 
-You can add `headers` to your request using the `Header` annotation.
+You can add `headers` to your request using the `Header` annotation:
 
 ```python
 class MyApi(RapidApi):
@@ -292,7 +297,7 @@ class MyApi(RapidApi):
     @get("/issues")
     def get_issues(self, x_version: Annotated[str, Header(default_factory=lambda: "2024.06")]): ...
 
-    # Header parameter with a default value
+    # Header parameter with an alias
     @get("/issues")
     def get_issues(self, my_parameter: Annotated[str, Header(alias="x-version")]): ...
 
@@ -301,61 +306,59 @@ class MyApi(RapidApi):
     def get_issues(self): ...
 ```
 
-## Body parameter
+## Body Parameters
 
 You can send a body with your request using the `Body` annotation. 
 
-This body can be 
- - a *raw* object with `Body`
- - a `dict` object with `JsonBody` 
- - a *Pydantic* object  with `PydanticBody`
- - one or more files with `FileBody`
+This body can be:
+ - A *raw* object with `Body`
+ - A `dict` object with `JsonBody` 
+ - A *Pydantic* object with `PydanticBody`
+ - One or more files with `FileBody`
 
- ```python
+```python
 class MyApi(RapidApi):
 
-    # send a string in request content
+    # Send a string in request content
     @post("/string")
     def post_string(self, body: Annotated[str, Body()]): ...
 
-    # send a dict in request content as json
+    # Send a dict in request content as JSON
     @post("/string")
     def post_json(self, body: Annotated[dict, JsonBody()]): ...
 
-    # send a Pydantic model in serialized as json
+    # Send a Pydantic model serialized as JSON
     @post("/model")
     def post_model(self, body: Annotated[MyPydanticClass, PydanticBody()]): ...
 
-    # send a multiple files
+    # Send multiple files
     @post("/files")
     def post_files(self, report: Annotated[bytes, FileBody()], image: Annotated[bytes, FileBody()]): ...
 
-    # send a form
+    # Send a form
     @post("/form")
     def post_form(self, my_param: Annotated[str, FormBody(alias="name")], extra_fields: Annotated[Dict[str, str], FormBody()]): ...
+```
 
- ```
-
- ## Xml Support
+## XML Support
 
- Xml is also supported is you use [Pydantic-Xml](https://pydantic-xml.readthedocs.io/), either for responses (if you type your function to return a `BaseXmlModel` subclass) or for POST/PUT content with `PydanticXmlBody`.
+XML is also supported if you use [Pydantic-Xml](https://pydantic-xml.readthedocs.io/), either for responses (if you type your function to return a `BaseXmlModel` subclass) or for POST/PUT content with `PydanticXmlBody`.
 
- ```python
+```python
 class ResponseXmlRootModel(BaseXmlModel): ...
 
 class MyApi(RapidApi):
 
-    # parse response xml content
+    # Parse response XML content
     @get("/get")
     def get_xml(self) -> ResponseXmlRootModel: ...
 
-    # serialize xml model automatically
+    # Serialize XML model automatically
     @post("/post")
     def post_xml(self, body: Annotated[ResponseXmlRootModel, PydanticXmlBody()]): ...
+```
 
- ```
-
- # Examples
+# Examples
 
 ## Authentication and Error Handling
 
@@ -424,4 +427,4 @@ if __name__ == "__main__":
     main()
 ```
 
-See [example directory](./examples/) for more examples
+See the [examples directory](./examples/) for more examples.

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

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

{rapid_api_client-0.7.0 → rapid_api_client-0.7.2}/rapid_api_client/__init__.py

@@ -30,21 +30,37 @@ Basic usage:
 
 from importlib.metadata import version
 
-from .annotations import Body as Body
-from .annotations import FileBody as FileBody
-from .annotations import FormBody as FormBody
-from .annotations import Header as Header
-from .annotations import JsonBody as JsonBody
-from .annotations import Path as Path
-from .annotations import PydanticBody as PydanticBody
-from .annotations import PydanticXmlBody as PydanticXmlBody
-from .annotations import Query as Query
-from .client import RapidApi as RapidApi
-from .decorator import delete as delete
-from .decorator import get as get
-from .decorator import http as http
-from .decorator import patch as patch
-from .decorator import post as post
-from .decorator import put as put
+from .annotations import (
+    Body,
+    FileBody,
+    FormBody,
+    Header,
+    JsonBody,
+    Path,
+    PydanticBody,
+    PydanticXmlBody,
+    Query,
+)
+from .client import RapidApi
+from .decorator import delete, get, http, patch, post, put, rapid
 
 __version__ = version(__name__)
+__all__ = [
+    "Body",
+    "delete",
+    "FileBody",
+    "FormBody",
+    "get",
+    "Header",
+    "http",
+    "JsonBody",
+    "patch",
+    "Path",
+    "post",
+    "put",
+    "PydanticBody",
+    "PydanticXmlBody",
+    "Query",
+    "rapid",
+    "RapidApi",
+]

{rapid_api_client-0.7.0 → rapid_api_client-0.7.2}/rapid_api_client/client.py

@@ -109,13 +109,9 @@ class RapidParameter(Generic[BA]):
         if self.name in ba.arguments:
             out = ba.arguments.get(self.name)
         else:
-            # check if pydantic model has a default value or a default factory
-            if self.annot.default is not PydanticUndefined:
-                out = self.annot.default
-            elif self.annot.default_factory is not None:
-                out = self.annot.default_factory()
-            else:
-                # No default value, raise an error
+            # Use pydantic default value if available
+            out = self.annot.get_default(call_default_factory=True)
+            if out is PydanticUndefined:
                 raise ValueError(f"Missing value for parameter {self.name}")
 
         if validate:
@@ -302,7 +298,7 @@ class ParameterManager:
                 # there is one PydanticBody parameter
                 if (value := first_body_param.get_value(ba)) is not None:
                     assert isinstance(value, BaseModel)
-                    return "content", value.model_dump_json()
+                    return "content", value.model_dump_json(by_alias=True)
             elif isinstance(first_body_param.annot, JsonBody):
                 # there is one JsonBody parameter
                 if (value := first_body_param.get_value(ba)) is not None:

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

@@ -17,7 +17,7 @@ sending the requests, and processing the responses.
 import inspect
 from functools import partial, wraps
 from inspect import signature
-from typing import Any, Mapping
+from typing import Any, Dict, Type
 
 from httpx import Response
 
@@ -29,7 +29,7 @@ def http(
     method: str,
     path: str,
     timeout: float | None = None,
-    headers: Mapping[str, str] | None = None,
+    headers: Dict[str, str] | None = None,
     raise_for_status: bool = True,
 ) -> Any:
     """
@@ -48,6 +48,7 @@ def http(
         path: The URL path template, which can contain placeholders for path parameters
         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
 
     Returns:
         A decorator function that wraps the API endpoint method
@@ -81,7 +82,7 @@ def http(
             # resolve the api path
             resolved_path = parameter_manager.get_resolved_path(path, ba)
 
-            build_kwargs: Mapping[str, Any] = {
+            build_kwargs: Dict[str, Any] = {
                 "headers": parameter_manager.get_headers(ba),
                 "params": parameter_manager.get_query(ba),
             }
@@ -121,6 +122,57 @@ def http(
     return decorator
 
 
+def rapid(**default_kwargs: Any) -> Any:
+    """
+    Class decorator to configure RapidApi subclasses with default parameters.
+
+    This decorator allows specifying default parameters for RapidApi subclasses
+    that will be passed to the constructor when instantiating the class.
+
+    Args:
+        **kwargs: Default arguments to pass to the RapidApi constructor
+
+    Returns:
+        A decorator function that wraps the RapidApi subclass
+
+    Example:
+        >>> from rapid_api_client import RapidApi, rapid, get
+        >>> from typing import Annotated
+        >>>
+        >>> @rapid(base_url="https://api.example.com", headers={"X-API-Key": "default-key"})
+        >>> class MyApi(RapidApi):
+        ...     @get("/users/{user_id}")
+        ...     def get_user(self, user_id: Annotated[int, Path()]): ...
+        >>>
+        >>> # No need to specify base_url or headers, they're provided by the decorator
+        >>> api = MyApi()
+        >>> user = api.get_user(123)
+        >>>
+        >>> # You can still override the defaults if needed
+        >>> custom_api = MyApi(headers={"X-API-Key": "custom-key"})
+    """
+
+    def decorator(cls: Type[RapidApi]) -> Type[RapidApi]:
+        # Store the original __init__ method
+        original_init = cls.__init__
+
+        @wraps(original_init)
+        def __init__(self: RapidApi, **init_kwargs: Any) -> None:
+            # Only apply default parameters if not present
+            for key, value in default_kwargs.items():
+                if key not in init_kwargs:
+                    init_kwargs[key] = value
+            # Call the original __init__ with the merged kwargs
+            original_init(self, **init_kwargs)
+
+        # Replace the __init__ method
+        cls.__init__ = __init__  # type: ignore
+
+        return cls
+
+    return decorator
+
+
 # Convenience decorators for common HTTP methods
 get = partial(http, "GET")
 post = partial(http, "POST")