celitech-sdk 1.0.0__py3-none-any.whl

celitech/services/purchases.py

@@ -0,0 +1,189 @@
+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.top_up_esim_request import TopUpEsimRequest
+from ..models.top_up_esim_ok_response import TopUpEsimOkResponse
+from ..models.list_purchases_ok_response import ListPurchasesOkResponse
+from ..models.get_purchase_consumption_ok_response import (
+    GetPurchaseConsumptionOkResponse,
+)
+from ..models.edit_purchase_request import EditPurchaseRequest
+from ..models.edit_purchase_ok_response import EditPurchaseOkResponse
+from ..models.create_purchase_request import CreatePurchaseRequest
+from ..models.create_purchase_ok_response import CreatePurchaseOkResponse
+
+
+class PurchasesService(BaseService):
+
+    @cast_models
+    def list_purchases(
+        self,
+        iccid: str = None,
+        after_date: str = None,
+        before_date: str = None,
+        after_cursor: str = None,
+        limit: float = None,
+        after: float = None,
+        before: float = None,
+    ) -> ListPurchasesOkResponse:
+        """This endpoint can be used to list all the successful purchases made between a given interval.
+
+        :param iccid: iccid, defaults to None
+        :type iccid: str, optional
+        :param after_date: Start date of the interval for filtering purchases in the format 'yyyy-MM-dd', defaults to None
+        :type after_date: str, optional
+        :param before_date: End date of the interval for filtering purchases in the format 'yyyy-MM-dd', defaults to None
+        :type before_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 after: Epoch value representing the start of the time interval for filtering purchases, defaults to None
+        :type after: float, optional
+        :param before: Epoch value representing the end of the time interval for filtering purchases, defaults to None
+        :type before: float, optional
+        ...
+        :raises RequestError: Raised when a request fails, with optional HTTP status code and details.
+        ...
+        :return: Successful Response
+        :rtype: ListPurchasesOkResponse
+        """
+
+        Validator(str).is_optional().validate(iccid)
+        Validator(str).is_optional().validate(after_date)
+        Validator(str).is_optional().validate(before_date)
+        Validator(str).is_optional().validate(after_cursor)
+        Validator(float).is_optional().validate(limit)
+        Validator(float).is_optional().validate(after)
+        Validator(float).is_optional().validate(before)
+
+        serialized_request = (
+            Serializer(f"{self.base_url}/purchases", self.get_default_headers())
+            .add_query("iccid", iccid)
+            .add_query("afterDate", after_date)
+            .add_query("beforeDate", before_date)
+            .add_query("afterCursor", after_cursor)
+            .add_query("limit", limit)
+            .add_query("after", after)
+            .add_query("before", before)
+            .serialize()
+            .set_method("GET")
+        )
+
+        response = self.send_request(serialized_request)
+
+        return ListPurchasesOkResponse._unmap(response)
+
+    @cast_models
+    def create_purchase(
+        self, request_body: CreatePurchaseRequest = None
+    ) -> CreatePurchaseOkResponse:
+        """This endpoint is used to purchase a new eSIM by providing the package details.
+
+        :param request_body: The request body., defaults to None
+        :type request_body: CreatePurchaseRequest, optional
+        ...
+        :raises RequestError: Raised when a request fails, with optional HTTP status code and details.
+        ...
+        :return: Successful Response
+        :rtype: CreatePurchaseOkResponse
+        """
+
+        Validator(CreatePurchaseRequest).is_optional().validate(request_body)
+
+        serialized_request = (
+            Serializer(f"{self.base_url}/purchases", self.get_default_headers())
+            .serialize()
+            .set_method("POST")
+            .set_body(request_body)
+        )
+
+        response = self.send_request(serialized_request)
+
+        return CreatePurchaseOkResponse._unmap(response)
+
+    @cast_models
+    def top_up_esim(self, request_body: TopUpEsimRequest = None) -> TopUpEsimOkResponse:
+        """This endpoint is used to top-up an eSIM with the previously associated destination by providing an existing ICCID and the package details. The top-up is not feasible for eSIMs in "DELETED" or "ERROR" state.
+
+        :param request_body: The request body., defaults to None
+        :type request_body: TopUpEsimRequest, optional
+        ...
+        :raises RequestError: Raised when a request fails, with optional HTTP status code and details.
+        ...
+        :return: Successful Response
+        :rtype: TopUpEsimOkResponse
+        """
+
+        Validator(TopUpEsimRequest).is_optional().validate(request_body)
+
+        serialized_request = (
+            Serializer(f"{self.base_url}/purchases/topup", self.get_default_headers())
+            .serialize()
+            .set_method("POST")
+            .set_body(request_body)
+        )
+
+        response = self.send_request(serialized_request)
+
+        return TopUpEsimOkResponse._unmap(response)
+
+    @cast_models
+    def edit_purchase(
+        self, request_body: EditPurchaseRequest = None
+    ) -> EditPurchaseOkResponse:
+        """This endpoint allows you to modify the dates of an existing package with a future activation start time. Editing can only be performed for packages that have not been activated, and it cannot change the package size. The modification must not change the package duration category to ensure pricing consistency.
+
+        :param request_body: The request body., defaults to None
+        :type request_body: EditPurchaseRequest, optional
+        ...
+        :raises RequestError: Raised when a request fails, with optional HTTP status code and details.
+        ...
+        :return: Successful Response
+        :rtype: EditPurchaseOkResponse
+        """
+
+        Validator(EditPurchaseRequest).is_optional().validate(request_body)
+
+        serialized_request = (
+            Serializer(f"{self.base_url}/purchases/edit", self.get_default_headers())
+            .serialize()
+            .set_method("POST")
+            .set_body(request_body)
+        )
+
+        response = self.send_request(serialized_request)
+
+        return EditPurchaseOkResponse._unmap(response)
+
+    @cast_models
+    def get_purchase_consumption(
+        self, purchase_id: str
+    ) -> GetPurchaseConsumptionOkResponse:
+        """This endpoint can be called for consumption notifications (e.g. every 1 hour or when the user clicks a button). It returns the data balance (consumption) of purchased packages.
+
+        :param purchase_id: purchase_id
+        :type purchase_id: str
+        ...
+        :raises RequestError: Raised when a request fails, with optional HTTP status code and details.
+        ...
+        :return: Successful Response
+        :rtype: GetPurchaseConsumptionOkResponse
+        """
+
+        Validator(str).validate(purchase_id)
+
+        serialized_request = (
+            Serializer(
+                f"{self.base_url}/purchases/{{purchaseId}}/consumption",
+                self.get_default_headers(),
+            )
+            .add_path("purchaseId", purchase_id)
+            .serialize()
+            .set_method("GET")
+        )
+
+        response = self.send_request(serialized_request)
+
+        return GetPurchaseConsumptionOkResponse._unmap(response)

celitech/services/utils/base_service.py

@@ -0,0 +1,63 @@
+from typing import Any, Dict
+from enum import Enum
+
+from .default_headers import DefaultHeaders, DefaultHeadersKeys
+from ...net.transport.request import Request
+from ...net.request_chain.request_chain import RequestChain
+from ...net.request_chain.handlers.hook_handler import HookHandler
+from ...net.request_chain.handlers.http_handler import HttpHandler
+from ...net.request_chain.handlers.retry_handler import RetryHandler
+
+
+class BaseService:
+    """
+    A base class for services providing common functionality.
+
+    :ivar str base_url: The base URL for the service.
+    :ivar dict _default_headers: A dictionary of default headers.
+    """
+
+    def __init__(self, base_url: str) -> None:
+        """
+        Initializes a BaseService instance.
+
+        :param str base_url: The base URL for the service. Defaults to None.
+        """
+        self.base_url = base_url
+        self._default_headers = DefaultHeaders()
+        self._request_handler = (
+            RequestChain()
+            .add_handler(RetryHandler())
+            .add_handler(HookHandler())
+            .add_handler(HttpHandler())
+        )
+
+    def set_base_url(self, base_url: str):
+        """
+        Sets the base URL for the service.
+
+        :param str base_url: The base URL to be set.
+        """
+        self.base_url = base_url
+
+        return self
+
+    def send_request(self, request: Request) -> dict:
+        """
+        Sends the given request.
+
+        :param Request request: The request to be sent.
+        :return: The response data.
+        :rtype: dict
+        """
+        response = self._request_handler.send(request)
+        return response.body
+
+    def get_default_headers(self) -> list:
+        """
+        Get the default headers.
+
+        :return: A list of the default headers.
+        :rtype: list
+        """
+        return self._default_headers.get_headers()

celitech/services/utils/default_headers.py

@@ -0,0 +1,57 @@
+from enum import Enum
+from typing import Any, Dict
+
+from ...net.headers.base_header import BaseHeader
+
+
+class DefaultHeadersKeys(Enum):
+    """
+    An enumeration of default headers.
+
+    :ivar str ACCESS_AUTH: The access token authentication header.
+    :ivar str BASIC_AUTH: The basic authentication header.
+    :ivar str API_KEY_AUTH: The API key authentication header.
+    """
+
+    ACCESS_AUTH = "access_token_auth"
+    BASIC_AUTH = "basic_auth"
+    API_KEY_AUTH = "api_key_auth"
+
+
+class DefaultHeaders:
+    """
+    A class to manage default headers.
+
+    :ivar Dict[str, BaseHeader] _default_headers: The default headers.
+    """
+
+    def __init__(self):
+        self._default_headers: Dict[str, BaseHeader] = {}
+
+    def set_header(self, key: DefaultHeadersKeys, value: BaseHeader) -> None:
+        """
+        Set a default header.
+
+        :param DefaultHeadersKeys key: The key of the header to set.
+        :param Any value: The value to set for the header.
+        """
+        self._default_headers[key.value] = value
+
+    def get_header(self, key: DefaultHeadersKeys) -> BaseHeader:
+        """
+        Get a default header.
+
+        :param DefaultHeadersKeys key: The key of the header to get.
+        :return: The value of the header.
+        :rtype: Any
+        """
+        return self._default_headers[key.value]
+
+    def get_headers(self) -> list:
+        """
+        Get the default headers.
+
+        :return: A list of the default headers.
+        :rtype: list
+        """
+        return list(self._default_headers.values())

celitech/services/utils/validator.py

@@ -0,0 +1,170 @@
+import re
+from typing import Union, Any, Type, Pattern, get_args
+from ...models.base import OneOfBaseModel
+
+
+class Validator:
+    """
+    A simple validator class for validating the type and pattern of a value.
+
+    :ivar Type[Any] _type: The expected type for the value.
+    :ivar bool _is_optional: Flag indicating whether the value is optional.
+    :ivar bool _is_array: Flag indicating whether the value is an array.
+    :ivar Pattern[str] _pattern: The regular expression pattern for validating the value.
+    :ivar int _min: The minimum value for validating the value.
+    :ivar int _max: The maximum value for validating the value.
+    """
+
+    def __init__(self, _type: Type[Any] = None):
+        """
+        Initializes a Validator instance.
+
+        :param Type[Any] _type: The expected type for the value. Defaults to None.
+        """
+        self._type: Type[Any] = _type
+        self._is_optional: bool = False
+        self._is_array: bool = False
+        self._pattern: Pattern[str] = None
+        self._min: int = None
+        self._max: int = None
+
+    def is_array(self) -> "Validator":
+        """
+        Marks the value as an array.
+
+        :return: The Validator instance for method chaining.
+        :rtype: Validator
+        """
+        self._is_array = True
+        return self
+
+    def is_optional(self) -> "Validator":
+        """
+        Marks the value as optional.
+
+        :return: The Validator instance for method chaining.
+        :rtype: Validator
+        """
+        self._is_optional = True
+        return self
+
+    def pattern(self, pattern: str) -> "Validator":
+        """
+        Specifies a regular expression pattern for validating the value.
+
+        :param str pattern: The regular expression pattern.
+        :return: The Validator instance for method chaining.
+        :rtype: Validator
+        """
+        self._pattern = re.compile(pattern)
+        return self
+
+    def min(self, min: int) -> "Validator":
+        """
+        Specifies a minimum value for validating the value.
+
+        :param int min: The minimum value.
+        :return: The Validator instance for method chaining.
+        :rtype: Validator
+        """
+        self._min = min
+        return self
+
+    def max(self, max: int) -> "Validator":
+        """
+        Specifies a maximum value for validating the value.
+
+        :param int max: The maximum value.
+        :return: The Validator instance for method chaining.
+        :rtype: Validator
+        """
+        self._max = max
+        return self
+
+    def validate(self, value: Any) -> None:
+        """
+        Validates the provided value based on the specified criteria.
+
+        :param Any value: The input that needs to be checked
+        :raises ValueError: If the value does not meet the specified validation criteria.
+        """
+        if not self._type:
+            raise TypeError("Invalid type: No type specified")
+        if self._is_optional and value is None:
+            return
+
+        self._validate_type(value)
+        self._validate_rules(value)
+
+    def _validate_type(self, value: Any) -> None:
+        """
+        Validates the type of the value.
+
+        :param Any value: The input that needs to be checked
+        :raises ValueError: If the value does not meet the expected type.
+        """
+        if self._is_one_of_type(self._type):
+            self._validate_one_of_type(value)
+        elif self._is_array:
+            self._validate_array_type(value)
+        elif not self._match_type(value):
+            raise TypeError(f"Invalid type: Expected {self._type}, got {type(value)}")
+
+    def _validate_one_of_type(self, value: Any) -> None:
+        """
+        Validates oneOf model type.
+
+        :param Any value: The input that needs to be checked
+        :raises ValueError: If the value does not match the oneOf rules.
+        """
+        class_list = {arg.__name__: arg for arg in get_args(self._type) if arg.__name__}
+        OneOfBaseModel.class_list = class_list
+        OneOfBaseModel.return_one_of(value)
+
+    def _validate_array_type(self, value: Any) -> None:
+        """
+        Validates the type of an array value.
+
+        :param Any value: The input that needs to be checked
+        :raises ValueError: If the array items do not match the expected type.
+        """
+        if any(self._match_type(v) is False for v in value):
+            raise TypeError(f"Invalid type: Expected {self._type}, got {type(value)}")
+
+    def _match_type(self, value: Any) -> bool:
+        """
+        Checks if the value matches the expected type.
+
+        :param Any value: The input that needs to be checked
+        :raises ValueError: If the value does not match the expected type.
+        """
+        is_numeric = self._type is float and isinstance(value, int)
+        if isinstance(value, self._type) or is_numeric:
+            return True
+        return False
+
+    def _validate_rules(self, value: Any) -> None:
+        """
+        Validate the rules specified for the value.
+
+        :param Any value: The input that needs to be validated
+        :raises ValueError: If the value does not meet the specified validation criteria.
+        """
+        if self._min is not None and value < self._min:
+            raise ValueError(f"Invalid value: {value} is less than {self._min}")
+        if self._max is not None and value > self._max:
+            raise ValueError(f"Invalid value: {value} is greater than {self._max}")
+        if self._pattern and not self._pattern.match(str(value)):
+            raise ValueError(
+                f"Invalid value: {value} does not match pattern {self._pattern}"
+            )
+
+    def _is_one_of_type(self, cls_type):
+        """
+        Checks if the provided type is a Union type.
+
+        :param Type[Any] cls_type: The type to be checked.
+        :return: True if the type is a Union type, False otherwise.
+        :rtype: bool
+        """
+        return hasattr(cls_type, "__origin__") and cls_type.__origin__ is Union

celitech_sdk-1.0.0.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.