celitech-sdk 1.0.0__py3-none-any.whl

celitech/net/transport/serializer.py

@@ -0,0 +1,249 @@
+from typing import Any, List
+from urllib.parse import quote
+
+from ...net.headers.base_header import BaseHeader
+from .request import Request
+from .utils import extract_original_data
+
+
+class Serializer:
+    """
+    A class for handling serialization of URL components such as headers, cookies, path parameters, and query parameters.
+
+    :ivar str url: The base URL to be serialized.
+    :ivar dict[str, str] headers: A dictionary containing headers for the request.
+    :ivar list[str] cookies: A list containing cookie strings for the request.
+    :ivar dict[str, str] path: A dictionary containing path parameters for the request.
+    :ivar list[str] query: A list containing query parameters for the request.
+    """
+
+    def __init__(self, url: str, default_headers: List[BaseHeader] = []):
+        """
+        Initializes a Serializer instance with the base URL.
+
+        :param str url: The base URL to be serialized.
+        :param list[BaseHeader] default_headers: A list of default headers to be added to the request. Defaults to an empty list.
+        """
+        self.url: str = url
+        self.headers: dict[str, str] = {}
+        self.cookies: list[str] = []
+        self.path: dict[str, str] = {}
+        self.query: list[str] = []
+
+        for header in default_headers:
+            for key, value in header.get_headers().items():
+                self.add_header(key, value)
+
+    def add_header(
+        self, key: str, data: Any, explode: bool = False, nullable: bool = False
+    ) -> "Serializer":
+        """
+        Adds a header to the request.
+
+        :param str key: The header key.
+        :param Any data: The data to be serialized as the header value.
+        :param bool explode: Flag indicating whether to explode the data.
+        :return: The Serializer instance for method chaining.
+        :rtype: Serializer
+        """
+        if not nullable and data is None:
+            return self
+
+        data = extract_original_data(data)
+
+        self.headers[key] = self._serialize_value(
+            data, explode=explode, quote_str_values=False
+        )
+        return self
+
+    def add_cookie(
+        self, key: str, data: Any, explode: bool = False, nullable: bool = False
+    ) -> "Serializer":
+        """
+        Adds a cookie to the request.
+
+        :param str key: The cookie key.
+        :param Any data: The data to be serialized as the cookie value.
+        :param bool explode: Flag indicating whether to explode the data.
+        :return: The Serializer instance for method chaining.
+        :rtype: Serializer
+        """
+        if not nullable and data is None:
+            return self
+
+        data = extract_original_data(data)
+
+        self.cookies.append(
+            f"{key}={self._serialize_value(data, explode=explode, quote_str_values=False)}"
+        )
+        return self
+
+    def add_path(
+        self,
+        key: str,
+        data: Any,
+        explode: bool = False,
+        style: str = "simple",
+        nullable: bool = False,
+    ) -> "Serializer":
+        """
+        Adds a path parameter to the request.
+
+        :param str key: The path parameter key.
+        :param Any data: The data to be serialized as the path parameter value.
+        :param bool explode: Flag indicating whether to explode the data.
+        :param str style: The style of serialization for the path parameter.
+        :return: The Serializer instance for method chaining.
+        :rtype: Serializer
+        """
+        if not nullable and data is None:
+            return self
+
+        data = extract_original_data(data)
+
+        if style == "simple":
+            self.path[key] = self._serialize_value(data=data, explode=explode)
+        elif style == "label":
+            separator = "." if explode else ","
+            self.path[key] = "." + self._serialize_value(
+                data=data, explode=explode, separator=separator
+            )
+        elif style == "matrix":
+            separator = ","
+
+            if isinstance(data, list) and explode:
+                separator = f";{key}="
+            elif explode:
+                separator = ";"
+
+            prefix = ";" if isinstance(data, dict) and explode else f";{key}="
+            self.path[key] = prefix + self._serialize_value(
+                data, explode=explode, separator=separator
+            )
+        else:
+            raise ValueError(f"Unsupported path style: {style}")
+
+        return self
+
+    def add_query(
+        self,
+        key: str,
+        data: Any,
+        explode: bool = True,
+        style: str = "form",
+        nullable: bool = False,
+    ) -> "Serializer":
+        """
+        Adds a query parameter to the request.
+
+        :param str key: The query parameter key.
+        :param Any data: The data to be serialized as the query parameter value.
+        :param bool explode: Flag indicating whether to explode the data.
+        :param str style: The style of serialization for the query parameter.
+        :return: The Serializer instance for method chaining.
+        :rtype: Serializer
+        """
+        if not nullable and data is None:
+            return self
+
+        data = extract_original_data(data)
+
+        if style == "form":
+            separator = "&" if explode else ","
+            prefix = "" if (explode and isinstance(data, dict)) else f"{key}="
+            query_param = f"{prefix}{self._serialize_value(data=data, explode=explode, separator=separator)}"
+        elif style == "spaceDelimited":
+            separator = f"&{key}=" if explode else f"%20"
+            query_param = f"{key}={self._serialize_value(data=data, explode=explode, separator=separator)}"
+        elif style == "pipeDelimited":
+            separator = f"&{key}=" if explode else "|"
+            query_param = f"{key}={self._serialize_value(data=data, explode=explode, separator=separator)}"
+        elif style == "deepObject":
+            query_param = "".join(
+                f"{key}[{k}]={quote(self._serialize_value(v))}&"
+                for k, v in data.items()
+            ).rstrip("&")
+
+        self.query.append(query_param)
+        return self
+
+    def serialize(self) -> Request:
+        """
+        Serializes the components and returns a Request object.
+
+        :return: The Request object containing the serialized components.
+        :rtype: Request
+        """
+        final_url = self._define_url()
+
+        if len(self.cookies) > 0:
+            self.headers["Cookie"] = ";".join(self.cookies)
+
+        return Request().set_url(final_url).set_headers(self.headers)
+
+    def _define_url(self) -> str:
+        """
+        Constructs the final URL by replacing path parameters and appending query parameters.
+
+        :return: The final URL.
+        :rtype: str
+        """
+        final_url = self.url
+
+        for key, value in self.path.items():
+            final_url = final_url.replace(f"{{{key}}}", value)
+
+        if len(self.query) > 0:
+            final_url += "?" + "&".join(self.query)
+
+        return final_url
+
+    def _serialize_value(
+        self,
+        data: Any,
+        separator: str = ",",
+        explode: bool = False,
+        quote_str_values: bool = True,
+    ) -> str:
+        """
+        Serializes a value based on the specified separator and explode flag.
+
+        :param Any data: The data to be serialized.
+        :param str separator: The separator used for serialization.
+        :param bool explode: Flag indicating whether to explode the data.
+        :return: The serialized value.
+        :rtype: str
+        """
+        if data is None:
+            return "null"
+
+        if isinstance(data, list):
+            return separator.join(
+                self._serialize_value(item, separator, explode) for item in data
+            )
+
+        if isinstance(data, dict):
+            if explode:
+                return separator.join(
+                    [
+                        f"{k}={self._serialize_value(v, separator, explode)}"
+                        for k, v in data.items()
+                    ]
+                )
+            else:
+                return separator.join(
+                    [
+                        self._serialize_value(item, separator, explode)
+                        for sublist in data.items()
+                        for item in sublist
+                    ]
+                )
+
+        if isinstance(data, str) and quote_str_values:
+            return quote(data)
+        if isinstance(data, bool):
+            return str(data).lower()
+        if isinstance(data, (int, float)):
+            return str(data)
+
+        return data

celitech/net/transport/utils.py

@@ -0,0 +1,28 @@
+from enum import Enum
+from typing import Any
+from ...models.base import BaseModel
+
+
+def extract_original_data(data: Any) -> Any:
+    """
+    Extracts the original data from internal models and enums.
+
+    :param Any data: The data to be extracted.
+    :return: The extracted data.
+    :rtype: Any
+    """
+    if data is None:
+        return None
+
+    data_type = type(data)
+
+    if issubclass(data_type, BaseModel):
+        return data._map()
+
+    if issubclass(data_type, Enum):
+        return data.value
+
+    if issubclass(data_type, list):
+        return [extract_original_data(item) for item in data]
+
+    return data

celitech/sdk.py

@@ -0,0 +1,30 @@
+from .services.destinations import DestinationsService
+from .services.packages import PackagesService
+from .services.purchases import PurchasesService
+from .services.e_sim import ESimService
+from .net.environment import Environment
+
+
+class Celitech:
+    def __init__(self, base_url: str = Environment.DEFAULT.value):
+        """
+        Initializes Celitech the SDK class.
+        """
+        self.destinations = DestinationsService(base_url=base_url)
+        self.packages = PackagesService(base_url=base_url)
+        self.purchases = PurchasesService(base_url=base_url)
+        self.e_sim = ESimService(base_url=base_url)
+
+    def set_base_url(self, base_url):
+        """
+        Sets the base URL for the entire SDK.
+        """
+        self.destinations.set_base_url(base_url)
+        self.packages.set_base_url(base_url)
+        self.purchases.set_base_url(base_url)
+        self.e_sim.set_base_url(base_url)
+
+        return self
+
+
+# c029837e0e474b76bc487506e8799df5e3335891efe4fb02bda7a1441840310c

celitech/services/destinations.py

@@ -0,0 +1,29 @@
+from .utils.validator import Validator
+from .utils.base_service import BaseService
+from ..net.transport.serializer import Serializer
+from ..models.utils.cast_models import cast_models
+from ..models.list_destinations_ok_response import ListDestinationsOkResponse
+
+
+class DestinationsService(BaseService):
+
+    @cast_models
+    def list_destinations(self) -> ListDestinationsOkResponse:
+        """Name of the destinations
+
+        ...
+        :raises RequestError: Raised when a request fails, with optional HTTP status code and details.
+        ...
+        :return: Successful Response
+        :rtype: ListDestinationsOkResponse
+        """
+
+        serialized_request = (
+            Serializer(f"{self.base_url}/destinations", self.get_default_headers())
+            .serialize()
+            .set_method("GET")
+        )
+
+        response = self.send_request(serialized_request)
+
+        return ListDestinationsOkResponse._unmap(response)

celitech/services/e_sim.py

@@ -0,0 +1,121 @@
+from .utils.validator import Validator
+from .utils.base_service import BaseService
+from ..net.transport.serializer import Serializer
+from ..models.utils.cast_models import cast_models
+from ..models.get_esim_ok_response import GetEsimOkResponse
+from ..models.get_esim_mac_ok_response import GetEsimMacOkResponse
+from ..models.get_esim_history_ok_response import GetEsimHistoryOkResponse
+from ..models.get_esim_device_ok_response import GetEsimDeviceOkResponse
+
+
+class ESimService(BaseService):
+
+    @cast_models
+    def get_esim(self, iccid: str) -> GetEsimOkResponse:
+        """Get status from eSIM
+
+        :param iccid: iccid
+        :type iccid: str
+        ...
+        :raises RequestError: Raised when a request fails, with optional HTTP status code and details.
+        ...
+        :return: Successful Response
+        :rtype: GetEsimOkResponse
+        """
+
+        Validator(str).validate(iccid)
+
+        serialized_request = (
+            Serializer(f"{self.base_url}/esim", self.get_default_headers())
+            .add_query("iccid", iccid)
+            .serialize()
+            .set_method("GET")
+        )
+
+        response = self.send_request(serialized_request)
+
+        return GetEsimOkResponse._unmap(response)
+
+    @cast_models
+    def get_esim_device(self, iccid: str) -> GetEsimDeviceOkResponse:
+        """Get device info from an installed eSIM
+
+        :param iccid: iccid
+        :type iccid: str
+        ...
+        :raises RequestError: Raised when a request fails, with optional HTTP status code and details.
+        ...
+        :return: Successful Response
+        :rtype: GetEsimDeviceOkResponse
+        """
+
+        Validator(str).validate(iccid)
+
+        serialized_request = (
+            Serializer(
+                f"{self.base_url}/esim/{{iccid}}/device", self.get_default_headers()
+            )
+            .add_path("iccid", iccid)
+            .serialize()
+            .set_method("GET")
+        )
+
+        response = self.send_request(serialized_request)
+
+        return GetEsimDeviceOkResponse._unmap(response)
+
+    @cast_models
+    def get_esim_history(self, iccid: str) -> GetEsimHistoryOkResponse:
+        """Get history from an eSIM
+
+        :param iccid: iccid
+        :type iccid: str
+        ...
+        :raises RequestError: Raised when a request fails, with optional HTTP status code and details.
+        ...
+        :return: Successful Response
+        :rtype: GetEsimHistoryOkResponse
+        """
+
+        Validator(str).validate(iccid)
+
+        serialized_request = (
+            Serializer(
+                f"{self.base_url}/esim/{{iccid}}/history", self.get_default_headers()
+            )
+            .add_path("iccid", iccid)
+            .serialize()
+            .set_method("GET")
+        )
+
+        response = self.send_request(serialized_request)
+
+        return GetEsimHistoryOkResponse._unmap(response)
+
+    @cast_models
+    def get_esim_mac(self, iccid: str) -> GetEsimMacOkResponse:
+        """Get MAC from eSIM
+
+        :param iccid: iccid
+        :type iccid: str
+        ...
+        :raises RequestError: Raised when a request fails, with optional HTTP status code and details.
+        ...
+        :return: Successful Response
+        :rtype: GetEsimMacOkResponse
+        """
+
+        Validator(str).validate(iccid)
+
+        serialized_request = (
+            Serializer(
+                f"{self.base_url}/esim/{{iccid}}/mac", self.get_default_headers()
+            )
+            .add_path("iccid", iccid)
+            .serialize()
+            .set_method("GET")
+        )
+
+        response = self.send_request(serialized_request)
+
+        return GetEsimMacOkResponse._unmap(response)

celitech/services/packages.py

@@ -0,0 +1,72 @@
+from .utils.validator import Validator
+from .utils.base_service import BaseService
+from ..net.transport.serializer import Serializer
+from ..models.utils.cast_models import cast_models
+from ..models.list_packages_ok_response import ListPackagesOkResponse
+
+
+class PackagesService(BaseService):
+
+    @cast_models
+    def list_packages(
+        self,
+        destination: str = None,
+        start_date: str = None,
+        end_date: str = None,
+        after_cursor: str = None,
+        limit: float = None,
+        start_time: int = None,
+        end_time: int = None,
+        duration: float = None,
+    ) -> ListPackagesOkResponse:
+        """List of available packages
+
+        :param destination: destination, defaults to None
+        :type destination: str, optional
+        :param start_date: start_date, defaults to None
+        :type start_date: str, optional
+        :param end_date: end_date, defaults to None
+        :type end_date: str, optional
+        :param after_cursor: after_cursor, defaults to None
+        :type after_cursor: str, optional
+        :param limit: limit, defaults to None
+        :type limit: float, optional
+        :param start_time: start_time, defaults to None
+        :type start_time: int, optional
+        :param end_time: end_time, defaults to None
+        :type end_time: int, optional
+        :param duration: duration, defaults to None
+        :type duration: float, optional
+        ...
+        :raises RequestError: Raised when a request fails, with optional HTTP status code and details.
+        ...
+        :return: Successful Response
+        :rtype: ListPackagesOkResponse
+        """
+
+        Validator(str).is_optional().validate(destination)
+        Validator(str).is_optional().validate(start_date)
+        Validator(str).is_optional().validate(end_date)
+        Validator(str).is_optional().validate(after_cursor)
+        Validator(float).is_optional().validate(limit)
+        Validator(int).is_optional().validate(start_time)
+        Validator(int).is_optional().validate(end_time)
+        Validator(float).is_optional().validate(duration)
+
+        serialized_request = (
+            Serializer(f"{self.base_url}/packages", self.get_default_headers())
+            .add_query("destination", destination)
+            .add_query("startDate", start_date)
+            .add_query("endDate", end_date)
+            .add_query("afterCursor", after_cursor)
+            .add_query("limit", limit)
+            .add_query("startTime", start_time)
+            .add_query("endTime", end_time)
+            .add_query("duration", duration)
+            .serialize()
+            .set_method("GET")
+        )
+
+        response = self.send_request(serialized_request)
+
+        return ListPackagesOkResponse._unmap(response)