quickspirit 2.1.0__py3-none-any.whl → 2.2.0__py3-none-any.whl

quickspirit/__init__.py

@@ -1,12 +1,12 @@
-from .http_async_downloader import HttpAsyncDownloader
-from .http_errors import RequestError
-from .http_async_client import HttpAsyncClient
-from .models import Result
-
-__all__ = [
-    "HttpAsyncDownloader",
-    "RequestError",
-    "HttpAsyncClient",
-    "Result",
-    "HttpAsyncClient",
-]
+from .http_async_downloader import HttpAsyncDownloader
+from .http_errors import RequestError
+from .http_async_client import HttpAsyncClient
+from .models import Result
+
+__all__ = [
+    "HttpAsyncDownloader",
+    "RequestError",
+    "HttpAsyncClient",
+    "Result",
+    "HttpAsyncClient",
+]

quickspirit/http_async_client.py

@@ -1,206 +1,239 @@
-from typing import Any, Callable, Dict, Optional
-
-from httpx import AsyncClient, HTTPStatusError, Response
-
-from .http_errors import RequestError
-from .models import Result
-
-
-class HttpAsyncClient:
-    """## Asynchronous HTTP client for making requests.
-
-    ### Attributes:
-        - client: The underlying AsyncClient instance for making requests.
-    """
-
-    async def send_request(
-        self,
-        method: str,
-        url: str,
-        data: Optional[Dict[str, Any]] = None,
-        json: Optional[Dict[str, Any]] = None,
-        headers: Optional[Dict[str, str]] = None,
-        url_params: Optional[Dict[str, Any]] = None,
-        files: Optional[Dict[str, Any]] = None,
-    ) -> Result:
-        """Make an HTTP request using the specified method.
-
-        Args:
-            method: The HTTP method to use (e.g., "get", "post").
-            url: The URL to send the request to.
-            body: The request body as a dictionary.
-            headers: Optional headers to include in the request.
-            url_params: Optional URL parameters to include in the request.
-
-        Returns:
-            A Result instance representing either the RAW response body
-            or a RequestError if there was an error.
-
-        Raises:
-            RequestError: If there was an error in the request.
-        """
-        try:
-            async with AsyncClient() as client:
-                request_method: Callable = getattr(client, method)
-
-                if method in {"get", "delete"}:
-                    response: Response = await request_method(
-                        url,
-                        headers=headers,
-                        params=url_params,
-                    )
-
-                else:
-                    response = await request_method(
-                        url,
-                        data=data,
-                        json=json,
-                        headers=headers,
-                        params=url_params,
-                        files=files,
-                    )
-
-                response.raise_for_status()
-
-                return Result(Data=response.read(), Error=None)
-
-        except HTTPStatusError as exec:
-            error_message = f"Endpoint returned: {exec.response.text}\n"
-
-            return Result(Error=RequestError(error_message), Data=None)
-
-    async def get(
-        self,
-        url: str,
-        headers: Optional[Dict[str, str]] = None,
-        url_params: Optional[Dict[str, Any]] = None,
-    ) -> Result:
-        """Make an HTTP GET request.
-
-        Args:
-            url: The URL to send the request to.
-            headers: Optional headers to include in the request.
-            url_params: Optional URL parameters to include in the request.
-
-        Returns:
-            The JSON response body as a dictionary or list, or a RequestError if there was an error.
-        """
-        return await self.send_request(
-            "get",
-            url,
-            headers=headers,
-            url_params=url_params,
-        )
-
-    async def post(
-        self,
-        url: str,
-        data: Optional[Dict[str, Any]] = None,
-        json: Optional[Dict[str, Any]] = None,
-        headers: Optional[Dict[str, str]] = None,
-        url_params: Optional[Dict[str, Any]] = None,
-        files: Optional[Dict[str, Any]] = None,
-    ) -> Result:
-        """Make an HTTP POST request.
-
-        Args:
-            url: The URL to send the request to.
-            body: The request body as a dictionary.
-            headers: Optional headers to include in the request.
-            url_params: Optional URL parameters to include in the request.
-
-        Returns:
-            The JSON response body as a dictionary or list, or a RequestError if there was an error.
-        """
-        return await self.send_request(
-            "post",
-            url,
-            data=data,
-            json=json,
-            headers=headers,
-            url_params=url_params,
-            files=files,
-        )
-
-    async def put(
-        self,
-        url: str,
-        data: Optional[Dict[str, Any]] = None,
-        json: Optional[Dict[str, Any]] = None,
-        headers: Optional[Dict[str, str]] = None,
-        url_params: Optional[Dict[str, Any]] = None,
-        files: Optional[Dict[str, Any]] = None,
-    ) -> Result:
-        """Make an HTTP PUT request.
-
-        Args:
-            url: The URL to send the request to.
-            body: The request body as a dictionary.
-            headers: Optional headers to include in the request.
-            url_params: Optional URL parameters to include in the request.
-
-        Returns:
-            The JSON response body as a dictionary or list, or a RequestError if there was an error.
-        """
-        return await self.send_request(
-            "put",
-            url,
-            data=data,
-            json=json,
-            headers=headers,
-            url_params=url_params,
-            files=files,
-        )
-
-    async def patch(
-        self,
-        url: str,
-        data: Optional[Dict[str, Any]] = None,
-        json: Optional[Dict[str, Any]] = None,
-        headers: Optional[Dict[str, str]] = None,
-        url_params: Optional[Dict[str, Any]] = None,
-        files: Optional[Dict[str, Any]] = None,
-    ) -> Result:
-        """Make an HTTP PATCH request.
-
-        Args:
-            url: The URL to send the request to.
-            body: The request body as a dictionary.
-            headers: Optional headers to include in the request.
-            url_params: Optional URL parameters to include in the request.
-
-        Returns:
-            The JSON response body as a dictionary or list, or a RequestError if there was an error.
-        """
-        return await self.send_request(
-            "patch",
-            url,
-            data=data,
-            json=json,
-            headers=headers,
-            url_params=url_params,
-            files=files,
-        )
-
-    async def delete(
-        self,
-        url: str,
-        headers: Optional[Dict[str, str]] = None,
-        url_params: Optional[Dict[str, Any]] = None,
-    ) -> Result:
-        """Make an HTTP DELETE request.
-
-        Args:
-            url: The URL to send the request to.
-            headers: Optional headers to include in the request.
-            url_params: Optional URL parameters to include in the request.
-
-        Returns:
-            The JSON response body as a dictionary or list, or a RequestError if there was an error.
-        """
-        return await self.send_request(
-            "delete",
-            url,
-            headers=headers,
-            url_params=url_params,
-        )
+from typing import Any, Callable, Dict, Optional
+
+from httpx import AsyncClient, HTTPStatusError, Response, Timeout
+
+from .http_errors import RequestError
+from .models import Result
+
+
+class HttpAsyncClient:
+    """## Asynchronous HTTP client for making requests.
+
+    ### Methods:
+        - send_request: inner function, modular call of the following requests:
+            - get
+            - post
+            - put
+            - patch
+            - delete
+    """
+
+    def __init__(self, timeout: Timeout = Timeout(5)) -> None:
+        """### The default client constructor.
+
+        ### Args:
+            - timeout: Timeout - how much the client waits before cancelling the request.
+        """
+        self.timeout: Timeout = timeout
+
+    async def get(
+        self,
+        url: str,
+        headers: Optional[Dict[str, str]] = None,
+        url_params: Optional[Dict[str, Any]] = None,
+        timeout: Optional[Timeout] = None,
+    ) -> Result:
+        """Make an HTTP GET request.
+
+        Args:
+            url: The URL to send the request to.
+            headers: Optional headers to include in the request.
+            url_params: Optional URL parameters to include in the request.
+            timeout: Optional timeout, defaults to the client-level timeout.
+
+        Returns:
+            The JSON response body as a dictionary or list, or a RequestError if there was an error.
+        """
+        return await self.__send_request(
+            "get",
+            url,
+            headers=headers,
+            url_params=url_params,
+            timeout=timeout,
+        )
+
+    async def post(
+        self,
+        url: str,
+        data: Optional[Dict[str, Any]] = None,
+        json: Optional[Dict[str, Any]] = None,
+        headers: Optional[Dict[str, str]] = None,
+        url_params: Optional[Dict[str, Any]] = None,
+        files: Optional[Dict[str, Any]] = None,
+        timeout: Optional[Timeout] = None,
+    ) -> Result:
+        """Make an HTTP POST request.
+
+        Args:
+            url: The URL to send the request to.
+            body: The request body as a dictionary.
+            headers: Optional headers to include in the request.
+            url_params: Optional URL parameters to include in the request.
+            timeout: Optional timeout, defaults to the client-level timeout.
+
+        Returns:
+            The JSON response body as a dictionary or list, or a RequestError if there was an error.
+        """
+        return await self.__send_request(
+            "post",
+            url,
+            data=data,
+            json=json,
+            headers=headers,
+            url_params=url_params,
+            files=files,
+            timeout=timeout,
+        )
+
+    async def put(
+        self,
+        url: str,
+        data: Optional[Dict[str, Any]] = None,
+        json: Optional[Dict[str, Any]] = None,
+        headers: Optional[Dict[str, str]] = None,
+        url_params: Optional[Dict[str, Any]] = None,
+        files: Optional[Dict[str, Any]] = None,
+        timeout: Optional[Timeout] = None,
+    ) -> Result:
+        """Make an HTTP PUT request.
+
+        Args:
+            url: The URL to send the request to.
+            body: The request body as a dictionary.
+            headers: Optional headers to include in the request.
+            url_params: Optional URL parameters to include in the request.
+            timeout: Optional timeout, defaults to the client-level timeout.
+
+        Returns:
+            The JSON response body as a dictionary or list, or a RequestError if there was an error.
+        """
+        return await self.__send_request(
+            "put",
+            url,
+            data=data,
+            json=json,
+            headers=headers,
+            url_params=url_params,
+            files=files,
+            timeout=timeout,
+        )
+
+    async def patch(
+        self,
+        url: str,
+        data: Optional[Dict[str, Any]] = None,
+        json: Optional[Dict[str, Any]] = None,
+        headers: Optional[Dict[str, str]] = None,
+        url_params: Optional[Dict[str, Any]] = None,
+        files: Optional[Dict[str, Any]] = None,
+        timeout: Optional[Timeout] = None,
+    ) -> Result:
+        """Make an HTTP PATCH request.
+
+        Args:
+            url: The URL to send the request to.
+            body: The request body as a dictionary.
+            headers: Optional headers to include in the request.
+            url_params: Optional URL parameters to include in the request.
+            timeout: Optional[Timeout] = None,
+
+        Returns:
+            The JSON response body as a dictionary or list, or a RequestError if there was an error.
+        """
+        return await self.__send_request(
+            "patch",
+            url,
+            data=data,
+            json=json,
+            headers=headers,
+            url_params=url_params,
+            files=files,
+            timeout=timeout,
+        )
+
+    async def delete(
+        self,
+        url: str,
+        headers: Optional[Dict[str, str]] = None,
+        url_params: Optional[Dict[str, Any]] = None,
+        timeout: Optional[Timeout] = None,
+    ) -> Result:
+        """Make an HTTP DELETE request.
+
+        Args:
+            url: The URL to send the request to.
+            headers: Optional headers to include in the request.
+            url_params: Optional URL parameters to include in the request.
+            timeout: Optional timeout, defaults to the client-level timeout.
+
+        Returns:
+            The JSON response body as a dictionary or list, or a RequestError if there was an error.
+        """
+        return await self.__send_request(
+            "delete",
+            url,
+            headers=headers,
+            url_params=url_params,
+            timeout=timeout,
+        )
+
+    async def __send_request(
+        self,
+        method: str,
+        url: str,
+        data: Optional[Dict[str, Any]] = None,
+        json: Optional[Dict[str, Any]] = None,
+        headers: Optional[Dict[str, str]] = None,
+        url_params: Optional[Dict[str, Any]] = None,
+        files: Optional[Dict[str, Any]] = None,
+        timeout: Optional[Timeout] = None,
+    ) -> Result:
+        """Make an HTTP request using the specified method.
+
+        Args:
+            method: The HTTP method to use (e.g., "get", "post").
+            url: The URL to send the request to.
+            body: The request body as a dictionary.
+            headers: Optional headers to include in the request.
+            url_params: Optional URL parameters to include in the request.
+            files: Optional file uris to upload.
+            timeout: Optional timeout, defaults to the client-level timeout.
+
+        Returns:
+            A Result instance representing either the RAW response body
+            or a RequestError if there was an error.
+
+        Raises:
+            RequestError: If there was an error in the request.
+        """
+        try:
+            async with AsyncClient(timeout=self.timeout) as client:
+                request_method: Callable = getattr(client, method)
+
+                if method in {"get", "delete"}:
+                    response: Response = await request_method(
+                        url,
+                        headers=headers,
+                        params=url_params,
+                        timeout=timeout or self.timeout,
+                    )
+
+                else:
+                    response = await request_method(
+                        url,
+                        data=data,
+                        json=json,
+                        headers=headers,
+                        params=url_params,
+                        files=files,
+                        timeout=timeout or self.timeout,
+                    )
+
+                response.raise_for_status()
+
+                return Result(data=response.read(), error=None)
+
+        except HTTPStatusError as exec:
+            error_message = f"Endpoint returned: {exec.response.text}\n"
+
+            return Result(error=RequestError(error_message), data=None)

quickspirit/http_async_downloader.py

@@ -1,33 +1,58 @@
-from typing import Any, Dict
-
-import aiofiles
-from httpx import AsyncClient
-
-
-class HttpAsyncDownloader:
-    async def __send_request(
-        self,
-        method: str,
-        url: str,
-        file_name: str,
-        data: Dict[str, Any] | None = None,
-        json: Dict[str, Any] | None = None,
-        headers: Dict[str, str] | None = None,
-        url_params: Dict[str, Any] | None = None,
-    ) -> None:
-        async with AsyncClient() as client:
-            async with client.stream(
-                method=method,
-                url=url,
-                data=data,
-                json=json,
-                headers=headers,
-                params=url_params,
-            ) as response:
-                async with aiofiles.open(file_name, "wb") as f:
-                    async for chunk in response.aiter_bytes():
-                        if chunk:
-                            await f.write(chunk)
-
-    async def get_file_from_url(self, url: str, file_path: str) -> None:
-        await self.__send_request("GET", url, file_path)
+from typing import Any, Dict
+
+import aiofiles
+from httpx import AsyncClient, Timeout
+
+
+class HttpAsyncDownloader:
+    """## Asynchronous HTTP downloader.
+
+    ### Methods:
+        - send_request: inner function, modular call of the following requests:
+            - get
+            - post
+            - put
+            - patch
+            - delete
+    """
+
+    def __init__(self, timeout: Timeout = Timeout(5)) -> None:
+        """### The default downloader constructor.
+
+        ### Args:
+            - timeout: Timeout - how much the client waits before cancelling the request.
+        """
+        self.timeout: Timeout = timeout
+
+    async def __send_request(
+        self,
+        method: str,
+        url: str,
+        file_name: str,
+        data: Dict[str, Any] | None = None,
+        json: Dict[str, Any] | None = None,
+        headers: Dict[str, str] | None = None,
+        url_params: Dict[str, Any] | None = None,
+        timeout: Timeout | None = None,
+    ) -> None:
+        async with AsyncClient() as client:
+            async with client.stream(
+                method=method,
+                url=url,
+                data=data,
+                json=json,
+                headers=headers,
+                params=url_params,
+                timeout=timeout,
+            ) as response:
+                async with aiofiles.open(file_name, "wb") as f:
+                    async for chunk in response.aiter_bytes():
+                        if chunk:
+                            await f.write(chunk)
+
+    async def get_file_from_url(
+        self, url: str, file_path: str, timeout: Timeout | None = Timeout(50)
+    ) -> None:
+        await self.__send_request(
+            "GET", url, file_path, timeout=timeout or self.timeout
+        )

quickspirit/http_errors.py

@@ -1,10 +1,10 @@
-class RequestError(Exception):
-    """Exception raised for request errors.
-
-    Attributes:
-        message -- Explanation of the error.
-    """
-
-    def __init__(self, message: str) -> None:
-        self.message = message
-        super().__init__(self.message)
+class RequestError(Exception):
+    """Exception raised for request errors.
+
+    Attributes:
+        message -- Explanation of the error.
+    """
+
+    def __init__(self, message: str) -> None:
+        self.message = message
+        super().__init__(self.message)

quickspirit/models.py

@@ -1,10 +1,10 @@
-from dataclasses import dataclass
-from typing import Optional
-
-from .http_errors import RequestError
-
-
-@dataclass
-class Result:
-    Error: Optional[RequestError]
-    Data: Optional[bytes]
+from dataclasses import dataclass
+from typing import Optional
+
+from .http_errors import RequestError
+
+
+@dataclass
+class Result:
+    error: Optional[RequestError]
+    data: Optional[bytes]