celitech-sdk 1.0.0__py3-none-any.whl

celitech/net/request_chain/handlers/base_handler.py

@@ -0,0 +1,39 @@
+from typing import Optional, Tuple
+from ...transport.request import Request
+from ...transport.response import Response
+from ...transport.request_error import RequestError
+
+
+class BaseHandler:
+    """
+    A class for sending the request through the chain of handlers.
+
+    :ivar BaseHandler _next_handler: The next handler in the chain.
+    """
+
+    def __init__(self):
+        """
+        Initialize a new instance of BaseHandler.
+        """
+        self._next_handler = None
+
+    def handle(
+        self, request: Request
+    ) -> Tuple[Optional[Response], Optional[RequestError]]:
+        """
+        Process the given request and return a response or an error.
+        This method must be implemented by all subclasses.
+
+        :param Request request: The request to handle.
+        :return: The response and any error that occurred.
+        :rtype: Tuple[Optional[Response], Optional[RequestError]]
+        """
+        raise NotImplementedError()
+
+    def set_next(self, handler: "BaseHandler"):
+        """
+        Set the next handler in the chain.
+
+        :param BaseHandler handler: The next handler.
+        """
+        self._next_handler = handler

celitech/net/request_chain/handlers/hook_handler.py

@@ -0,0 +1,47 @@
+from typing import Optional, Tuple
+
+
+from .base_handler import BaseHandler
+from ....hooks.hook import CustomHook
+from ...transport.request import Request
+from ...transport.response import Response
+from ...transport.request_error import RequestError
+
+
+class HookHandler(BaseHandler):
+    """
+    Handler for calling hooks.
+
+    :ivar Hook _hook: The hook to be called. This is a placeholder and should be replaced with an instance of the actual hook class.
+    """
+
+    def __init__(self):
+        """
+        Initialize a new instance of HookHandler.
+        """
+        super().__init__()
+        self._hook = CustomHook()
+
+    def handle(
+        self, request: Request
+    ) -> Tuple[Optional[Response], Optional[RequestError]]:
+        """
+        Call the beforeRequest hook before passing the request to the next handler in the chain.
+        Call the afterResponse hook after receiving a response from the next handler in the chain.
+        Call the onError hook if an error occurs in the next handler in the chain.
+
+        :param Request request: The request to handle.
+        :return: The response and any error that occurred.
+        :rtype: Tuple[Optional[Response], Optional[RequestError]]
+        """
+        if self._next_handler is None:
+            raise RequestError("Handler chain is incomplete")
+
+        self._hook.before_request(request)
+        response, error = self._next_handler.handle(request)
+        if error is not None and error.is_http_error:
+            self._hook.on_error(error, request, error.response)
+        else:
+            self._hook.after_response(request, response)
+
+        return response, error

celitech/net/request_chain/handlers/http_handler.py

@@ -0,0 +1,80 @@
+import requests
+
+from requests.exceptions import Timeout
+from typing import Optional, Tuple
+from .base_handler import BaseHandler
+from ...transport.request import Request
+from ...transport.response import Response
+from ...transport.request_error import RequestError
+
+
+class HttpHandler(BaseHandler):
+    """
+    Handler for making HTTP requests.
+    This handler sends the request to the specified URL and returns the response.
+
+    :ivar int _timeout_in_seconds: The timeout for the HTTP request in seconds.
+    """
+
+    def __init__(self):
+        """
+        Initialize a new instance of HttpHandler.
+        """
+        super().__init__()
+        self._timeout_in_seconds = 60
+
+    def handle(
+        self, request: Request
+    ) -> Tuple[Optional[Response], Optional[RequestError]]:
+        """
+        Send the request to the specified URL and return the response.
+
+        :param Request request: The request to send.
+        :return: The response and any error that occurred.
+        :rtype: Tuple[Optional[Response], Optional[RequestError]]
+        """
+        try:
+            request_args = self._get_request_data(request)
+
+            result = requests.request(
+                request.method,
+                request.url,
+                headers=request.headers,
+                timeout=self._timeout_in_seconds,
+                **request_args,
+            )
+            response = Response(result)
+
+            if result.status_code >= 400:
+                return None, RequestError(
+                    message=f"{result.status_code} error in request to: {request.url}",
+                    status_code=result.status_code,
+                    response=response,
+                )
+
+            return response, None
+        except Timeout:
+            return None, RequestError("Request timed out")
+
+    def _get_request_data(self, request: Request) -> dict:
+        """
+        Get the request arguments based on the request headers and data.
+
+        :param Request request: The request object.
+        :return: The request arguments.
+        :rtype: dict
+        """
+        headers = request.headers or {}
+        data = request.body or {}
+        content_type = headers.get("Content-Type", "application/json")
+
+        if request.method == "GET" and not data:
+            return {}
+
+        if content_type.startswith("application/") and "json" in content_type:
+            return {"json": data}
+
+        if "multipart/form-data" in content_type:
+            return {"files": data}
+
+        return {"data": data}

celitech/net/request_chain/handlers/retry_handler.py

@@ -0,0 +1,65 @@
+import random
+
+from typing import Optional, Tuple
+from time import sleep
+from .base_handler import BaseHandler
+from ...transport.request import Request
+from ...transport.response import Response
+from ...transport.request_error import RequestError
+
+
+class RetryHandler(BaseHandler):
+    """
+    Handler for retrying requests.
+    Retries the request if the previous handler in the chain returned an error or a response with a status code of 500 or higher.
+
+    :ivar int _max_attempts: The maximum number of retry attempts.
+    :ivar int _delay_in_milliseconds: The delay between retry attempts in milliseconds.
+    """
+
+    def __init__(self):
+        """
+        Initialize a new instance of RetryHandler.
+        """
+        super().__init__()
+        self._max_attempts = 3
+        self._delay_in_milliseconds = 150
+
+    def handle(
+        self, request: Request
+    ) -> Tuple[Optional[Response], Optional[RequestError]]:
+        """
+        Retry the request if the previous handler in the chain returned an error or a response with a status code of 500 or higher.
+
+        :param Request request: The request to retry.
+        :return: The response and any error that occurred.
+        :rtype: Tuple[Optional[Response], Optional[RequestError]]
+        :raises RequestError: If the handler chain is incomplete.
+        """
+        if self._next_handler is None:
+            raise RequestError("Handler chain is incomplete")
+
+        response, error = self._next_handler.handle(request)
+
+        try_count = 0
+        while try_count < self._max_attempts and self._should_retry(error):
+            jitter = random.uniform(0.5, 1.5)
+            delay = self._delay_in_milliseconds * (2**try_count) * jitter / 1000
+            sleep(delay)
+            response, error = self._next_handler.handle(request)
+            try_count += 1
+
+        return response, error
+
+    def _should_retry(self, error: Optional[RequestError]) -> bool:
+        """
+        Determine whether the request should be retried.
+
+        :param Optional[Response] response: The response from the previous handler.
+        :param Optional[RequestError] error: The error from the previous handler.
+        :return: True if the request should be retried, False otherwise.
+        :rtype: bool
+        """
+        if not error:
+            return False
+        return error.status_code == 408 or error.status_code >= 500

celitech/net/request_chain/request_chain.py

@@ -0,0 +1,57 @@
+from typing import Optional
+from .handlers.base_handler import BaseHandler
+from ..transport.request import Request
+from ..transport.response import Response
+
+
+class RequestChain:
+    """
+    Class representing a chain of request handlers.
+    Handlers are added to the chain and the request is passed through each handler in the order they were added.
+
+    :ivar Optional[BaseHandler] _head: The first handler in the chain.
+    :ivar Optional[BaseHandler] _tail: The last handler in the chain.
+    """
+
+    def __init__(self):
+        """
+        Initialize a new instance of RequestChain.
+        """
+        self._head: Optional[BaseHandler] = None
+        self._tail: Optional[BaseHandler] = None
+
+    def add_handler(self, handler: BaseHandler) -> "RequestChain":
+        """
+        Add a handler to the chain.
+
+        :param BaseHandler handler: The handler to add.
+        :return: The current instance of RequestChain to allow for method chaining.
+        :rtype: RequestChain
+        """
+        if self._head is None:
+            self._head = handler
+            self._tail = handler
+        else:
+            self._tail.set_next(handler)
+            self._tail = handler
+
+        return self
+
+    def send(self, request: Request) -> Response:
+        """
+        Send the request through the chain of handlers.
+
+        :param Request request: The request to send.
+        :return: The response from the request.
+        :rtype: Response
+        :raises RuntimeError: If the RequestChain is empty.
+        """
+        if self._head is not None:
+            response, error = self._head.handle(request)
+
+            if error is not None:
+                raise error
+
+            return response
+        else:
+            raise RuntimeError("RequestChain is empty")

celitech/net/transport/request.py

@@ -0,0 +1,89 @@
+from typing import Any
+from .utils import extract_original_data
+
+
+class Request:
+    """
+    A simple HTTP request builder class using the requests library.
+
+    Example Usage:
+    ```python
+    # Create a Request object
+    request = Request()
+
+    # Set request parameters
+    request.set_url('https://yourendpoint.com/') \
+           .set_method('GET') \
+           .set_headers({'Content-Type': 'application/json'}) \
+           .set_body(None)  # For GET requests, the body should be None
+
+    # Send the HTTP request
+    response = request.send()
+    ```
+
+    :ivar str url: The URL of the API endpoint.
+    :ivar str method: The HTTP method for the request.
+    :ivar dict headers: Dictionary of headers to include in the request.
+    :ivar Any body: Request body.
+    """
+
+    def __init__(self):
+        self.url = None
+        self.method = None
+        self.headers = None
+        self.body = None
+
+    def set_url(self, url: str) -> "Request":
+        """
+        Set the URL of the API endpoint.
+
+        :param str url: The URL of the API endpoint.
+        :return: The updated Request object.
+        :rtype: Request
+        """
+        self.url = url
+        return self
+
+    def set_headers(self, headers: dict) -> "Request":
+        """
+        Set the headers for the HTTP request.
+
+        :param dict headers: Dictionary of headers to include in the request.
+        :return: The updated Request object.
+        :rtype: Request
+        """
+        self.headers = headers
+        return self
+
+    def set_method(self, method: str) -> "Request":
+        """
+        Set the HTTP method for the request.
+
+        :param str method: The HTTP method (e.g., 'GET', 'POST', 'PUT', 'DELETE', etc.).
+        :return: The updated Request object.
+        :rtype: Request
+        """
+        self.method = method
+        return self
+
+    def set_body(self, body: Any, content_type: str = "application/json") -> "Request":
+        """
+        Set the request body (e.g., JSON payload).
+
+        :param Any body: Request body.
+        :param str content_type: The content type of the request body. Default is "application/json".
+        :return: The updated Request object.
+        :rtype: Request
+        """
+        self.body = extract_original_data(body)
+        self.headers["Content-Type"] = content_type
+        return self
+
+    def __str__(self) -> str:
+        """
+        Return a string representation of the Request object.
+
+        :return: A string representation of the Request object.
+        :rtype: str
+        """
+        return f"Request(url={self.url}, method={self.method}, headers={self.headers}, body={self.body})"

celitech/net/transport/request_error.py

@@ -0,0 +1,53 @@
+from .response import Response
+from typing import Optional
+
+
+class RequestError(IOError):
+    """
+    Class representing a Request Error.
+
+    :ivar bool is_http_error: Indicates if the error is an HTTP error.
+    :ivar int status_code: The status code of the HTTP error.
+    :ivar Optional[Response] response: The response associated with the error.
+    """
+
+    def __init__(
+        self,
+        message: str,
+        status_code: Optional[int] = None,
+        response: Optional[Response] = None,
+        stack: Optional["RequestError"] = None,
+    ):
+        """
+        Initialize a new instance of RequestError.
+
+        :param str message: The error message.
+        :param Optional[int] status_code: The status code of the HTTP error.
+        :param Optional[Response] response: The response associated with the error.
+        """
+        super().__init__(message)
+        self.response = response
+        self.stack = stack
+
+        if status_code is not None:
+            self.status_code = status_code
+            self.is_http_error = True
+        else:
+            self.status_code = -1
+            self.is_http_error = False
+
+    def __str__(self):
+        """
+        Get the string representation of the error.
+
+        :return: The string representation of the error.
+        :rtype: str
+        """
+        error_stack = []
+        current_error = self
+        while current_error is not None:
+            error_stack.append(
+                f"Error: {super().__str__()}, Status Code: {current_error.status_code}"
+            )
+            current_error = current_error.stack
+        return "\n".join(error_stack)

celitech/net/transport/response.py

@@ -0,0 +1,57 @@
+from requests import Response as RequestsResponse
+from urllib.parse import parse_qs
+
+
+class Response:
+    """
+    A simple HTTP response wrapper class using the requests library.
+
+    :ivar int status_code: The status code of the HTTP response.
+    :ivar dict headers: The headers of the HTTP response.
+    :ivar str body: The body of the HTTP response.
+    """
+
+    def __init__(self, response: RequestsResponse):
+        """
+        Initializes a Response object.
+
+        :param RequestsResponse response: The requests.Response object.
+        """
+        self.status_code = response.status_code
+        self.headers = response.headers
+        self.body = self._get_response_body(response)
+
+    def __str__(self) -> str:
+        """
+        Return a string representation of the Response object.
+
+        :return: A string representation of the Response object.
+        :rtype: str
+        """
+        return f"Response(status_code={self.status_code}, headers={self.headers}, body={self.body})"
+
+    def _get_response_body(self, response: RequestsResponse) -> str:
+        """
+        Extracts the response body from a given HTTP response.
+
+        This method attempts to parse the response body based on its content type.
+        If the content type is JSON, it tries to parse the body as JSON.
+        If the content type is text or XML, it returns the raw text.
+        If the content type is 'application/x-www-form-urlencoded', it parses the body as a query string.
+        For all other content types, it returns the raw binary content.
+
+        :param RequestsResponse response: The HTTP response received from a request.
+        :return: The parsed response body.
+        :rtype: str or dict or bytes
+        """
+        try:
+            return response.json()
+        except ValueError:
+            content_type = response.headers.get("Content-Type", "").lower()
+            if "text/" in content_type or content_type == "application/xml":
+                return response.text
+            elif content_type == "application/x-www-form-urlencoded":
+                parsed_response = parse_qs(response.text)
+                return {k: v[0] for k, v in parsed_response.items()}
+            else:
+                return response.content