celitech-sdk 1.0.0__py3-none-any.whl

celitech/__init__.py

@@ -0,0 +1,2 @@
+from .sdk import Celitech
+from .net.environment import Environment

celitech/hooks/hook.py

@@ -0,0 +1,95 @@
+import os
+import time
+import requests
+
+
+class Request:
+    def __init__(self, method, url, headers, body=""):
+        self.method = method
+        self.url = url
+        self.headers = headers
+        self.body = body
+
+    def __str__(self):
+        return f"method={self.method}, url={self.url}, headers={self.headers}, body={self.body})"
+
+
+class Response:
+    def __init__(self, status, headers, body):
+        self.status = status
+        self.headers = headers
+        self.body = body
+
+    def __str__(self):
+        return "Response(status={}, headers={}, body={})".format(
+            self.status, self.headers, self.body
+        )
+
+
+class CustomHook:
+
+    def __init__(self):
+        self.CURRENT_TOKEN = None
+        self.CURRENT_EXPIRY = 0
+
+    def before_request(self, request: Request):
+        if request.url.endswith("/oauth/token"):
+            return
+
+        # Get the client_id and client_secret from environment variables
+        client_id = os.getenv("CLIENT_ID", "")
+        client_secret = os.getenv("CLIENT_SECRET", "")
+
+        if not client_id or not client_secret:
+            print("Missing CLIENT_ID and/or CLIENT_SECRET environment variables")
+            return
+        else:
+            # Check if CURRENT_TOKEN is missing or CURRENT_EXPIRY is in the past
+            if not self.CURRENT_TOKEN or self.CURRENT_EXPIRY < time.time() * 1000:
+                # Assuming Celitech class and its methods are defined appropriately
+                sdk = Celitech(environment=Environment.TOKEN_SERVER)
+
+                # Prepare the request payload for fetching a fresh OAuth token
+                input_data = {
+                    "client_id": client_id,
+                    "client_secret": client_secret,
+                    "grant_type": "client_credentials",
+                }
+
+                # Fetch a fresh OAuth token
+                token_response = self.do_post(request, input_data, "/oauth2/token")
+                expires_in = token_response.get("expires_in")
+                access_token = token_response.get("access_token")
+
+                if not expires_in or not access_token:
+                    print("There is an issue with getting the OAuth token")
+                    return
+
+                self.CURRENT_EXPIRY = time.time() * 1000 + expires_in * 1000
+                self.CURRENT_TOKEN = access_token
+
+            # Set the Bearer token in the request header
+            authorization = f"Bearer {self.CURRENT_TOKEN}"
+            request.headers.update({"Authorization": authorization})
+
+    def do_post(self, request: Request, input_data: dict, url_endpoint: str):
+        full_url = "https://auth.celitech.net/oauth2/token"
+
+        try:
+            response = requests.post(
+                full_url,
+                data=input_data,
+                headers={"Content-type": "application/x-www-form-urlencoded"},
+                verify=True,
+            )
+
+            return response.json() if response.ok else None
+        except Exception as error:
+            print("Error in posting the request:", error)
+            return None
+
+    def after_response(self, request: Request, response: Response):
+        pass
+
+    def on_error(self, error: Exception, request: Request, response: Response):
+        pass

celitech/models/__init__.py

@@ -0,0 +1,14 @@
+from .list_destinations_ok_response import ListDestinationsOkResponse
+from .list_packages_ok_response import ListPackagesOkResponse
+from .list_purchases_ok_response import ListPurchasesOkResponse
+from .create_purchase_request import CreatePurchaseRequest
+from .create_purchase_ok_response import CreatePurchaseOkResponse
+from .top_up_esim_request import TopUpEsimRequest
+from .top_up_esim_ok_response import TopUpEsimOkResponse
+from .edit_purchase_request import EditPurchaseRequest
+from .edit_purchase_ok_response import EditPurchaseOkResponse
+from .get_purchase_consumption_ok_response import GetPurchaseConsumptionOkResponse
+from .get_esim_ok_response import GetEsimOkResponse
+from .get_esim_device_ok_response import GetEsimDeviceOkResponse
+from .get_esim_history_ok_response import GetEsimHistoryOkResponse
+from .get_esim_mac_ok_response import GetEsimMacOkResponse

celitech/models/base.py

@@ -0,0 +1,251 @@
+import re
+from typing import List, Union, get_origin, get_args
+from enum import Enum
+
+
+class BaseModel:
+    """
+    A base class that most of the models in the SDK inherited from.
+    """
+
+    def __init__(self):
+        pass
+
+    def _pattern_matching(self, value: str, pattern: str, variable_name: str):
+        """
+        Checks if a value matches a regex pattern and returns the value if there's a match.
+
+        :param value: The value to be checked.
+        :type value: str
+        :param pattern: The regex pattern.
+        :type pattern: str
+        :param variable_name: The variable name.
+        :type variable_name: str
+        :return: The value if it matches the pattern.
+        :rtype: str
+        :raises ValueError: If the value does not match the pattern.
+        """
+        if value is None:
+            return None
+
+        if re.match(r"{}".format(pattern), value):
+            return value
+        else:
+            raise ValueError(f"Invalid value for {variable_name}: must match {pattern}")
+
+    def _enum_matching(
+        self, value: Union[str, Enum], enum_values: List[str], variable_name: str
+    ):
+        """
+        Checks if a value (str or enum) matches the required enum values and returns the value if there's a match.
+
+        :param value: The value to be checked.
+        :type value: Union[str, Enum]
+        :param enum_values: The list of valid enum values.
+        :type enum_values: List[str]
+        :param variable_name: The variable name.
+        :type variable_name: str
+        :return: The value if it matches one of the enum values.
+        :rtype: Union[str, Enum]
+        :raises ValueError: If the value does not match any of the enum values.
+        """
+        if value is None:
+            return None
+
+        str_value = value.value if isinstance(value, Enum) else value
+        if str_value in enum_values:
+            return value
+        else:
+            raise ValueError(
+                f"Invalid value for {variable_name}: must match one of {enum_values}"
+            )
+
+    def _define_object(self, input_data, input_class):
+        """
+        Check if the input data is an instance of the input class and return the input data if it is.
+        Otherwise, return an instance of the input class.
+
+        :param input_data: The input data to be checked.
+        :param input_class: The class that the input data should be an instance of.
+        :return: The input data if it is an instance of input_class, otherwise an instance of input_class.
+        :rtype: object
+        """
+        if input_data is None:
+            return None
+        elif isinstance(input_data, input_class):
+            return input_data
+        else:
+            return input_class._unmap(input_data)
+
+    def _define_list(self, input_data, list_class):
+        """
+        Create a list of instances of a specified class from input data.
+
+        :param input_data: The input data to be transformed into a list of instances.
+        :param list_class: The class that each instance in the list should be an instance of.
+        :return: A list of instances of list_class.
+        :rtype: list
+        """
+
+        if input_data is None:
+            return None
+
+        result = []
+        for item in input_data:
+            if hasattr(list_class, "__args__") and len(list_class.__args__) > 0:
+                class_list = self.__create_class_map(list_class)
+                OneOfBaseModel.class_list = class_list
+                result.append(OneOfBaseModel.return_one_of(item))
+            elif issubclass(list_class, Enum):
+                result.append(
+                    self._enum_matching(item, list_class.list(), list_class.__name__)
+                )
+            elif isinstance(item, list_class):
+                result.append(item)
+            elif isinstance(item, dict):
+                result.append(list_class._unmap(item))
+            else:
+                result.append(list_class(item))
+        return result
+
+    def __create_class_map(self, union_type):
+        """
+        Create a dictionary that maps class names to the actual classes in a Union type.
+
+        :param union_type: The Union type to create a class map for.
+        :return: A dictionary mapping class names to classes.
+        :rtype: dict
+        """
+        class_map = {}
+        for arg in union_type.__args__:
+            if arg.__name__:
+                class_map[arg.__name__] = arg
+        return class_map
+
+    def _get_representation(self, level=0):
+        """
+        Get a string representation of the model.
+
+        :param int level: The indentation level.
+        :return: A string representation of the model.
+        """
+        indent = "    " * level
+        representation_lines = []
+
+        for attr, value in vars(self).items():
+            if value is not None:
+                value_representation = (
+                    value._get_representation(level + 1)
+                    if hasattr(value, "_get_representation")
+                    else repr(value)
+                )
+                representation_lines.append(
+                    f"{indent}    {attr}={value_representation}"
+                )
+
+        return (
+            f"{self.__class__.__name__}(\n"
+            + ",\n".join(representation_lines)
+            + f"\n{indent})"
+        )
+
+    def __str__(self):
+        return self._get_representation()
+
+    def __repr__(self):
+        return self._get_representation()
+
+
+class OneOfBaseModel:
+    """
+    A base class for handling 'oneOf' models where multiple class constructors are available,
+    and the appropriate one is determined based on the input data.
+
+    :ivar dict class_list: A dictionary mapping class names to their constructors.
+    """
+
+    class_list = {}
+
+    @classmethod
+    def return_one_of(cls, input_data):
+        """
+        Attempts to initialize an instance of one of the classes in the class_list
+        based on the provided input data.
+
+        :param input_data: Input data used for initialization.
+        :return: An instance of one of the classes specified.
+        :rtype: object
+        :raises ValueError: If no class can be initialized with the provided input data,
+            or if optional parameters don't match the input data.
+        """
+        if input_data is None:
+            return None
+
+        if isinstance(input_data, (str, float, int, bool)):
+            return input_data
+
+        for class_constructor in cls.class_list.values():
+            try:
+                # Check if the class is a only a TypeHint
+                origin = get_origin(class_constructor)
+                if origin is not None and isinstance(input_data, list):
+                    list_instance = cls._get_list_instance(
+                        input_data, class_constructor, origin
+                    )
+                    if list_instance is not None:
+                        return list_instance
+                    else:
+                        continue  # Try the next class constructor
+
+                # Check if the input_data is already an instance of the class
+                if isinstance(input_data, class_constructor):
+                    return input_data
+
+                # Check if the input_data is a dictionary that can be used to initialize the class
+                elif isinstance(input_data, dict):
+                    instance = class_constructor._unmap(input_data)
+                    if cls._check_params(input_data, instance):
+                        return instance
+            except Exception:
+                pass
+
+        raise ValueError(
+            f"Input data must match one of the models: {list(cls.class_list.keys())}"
+        )
+
+    @classmethod
+    def _get_list_instance(cls, input_data, class_constructor, origin):
+        """
+        Return the list of elements for a given class constructor and origin type.
+
+        :param input_data: The input data to check.
+        :param class_constructor: The constructor of the class to check against.
+        :param origin: The origin type to check against.
+        :return: The input data if all elements are instances of the type specified in the class_constructor,
+            or a new list with each item unmapped.
+        """
+        args = get_args(class_constructor)
+        if isinstance(input_data, origin):
+            if args and len(args) == 1 and isinstance(input_data, list):
+                inner_type = args[0]
+                if all(isinstance(item, inner_type) for item in input_data):
+                    return input_data
+                else:
+                    return [inner_type._unmap(item) for item in input_data]
+
+    @classmethod
+    def _check_params(cls, raw_input, instance):
+        """
+        Checks if the optional parameters in the instance match the keys in the input data,
+        ensuring compliance with one of the models.
+
+        :param dict raw_input: Input data used for initialization.
+        :param object instance: An instance of one of the classes specified in the 'oneOf' model.
+        :return: True if the optional parameters in the instance match the keys in the input data, False otherwise.
+        """
+        input_values = {k: v for k, v in raw_input.items() if v is not None}.values()
+        instance_map = instance._map()
+        instance_values = {
+            k: v for k, v in instance_map.items() if v is not None
+        }.values()
+        return len(input_values) == len(instance_values)

celitech/models/create_purchase_ok_response.py

@@ -0,0 +1,85 @@
+from .utils.json_map import JsonMap
+from .base import BaseModel
+
+
+@JsonMap(
+    {
+        "id_": "id",
+        "package_id": "packageId",
+        "start_date": "startDate",
+        "end_date": "endDate",
+        "created_date": "createdDate",
+        "start_time": "startTime",
+        "end_time": "endTime",
+    }
+)
+class CreatePurchaseOkResponsePurchase(BaseModel):
+    """CreatePurchaseOkResponsePurchase
+
+    :param id_: ID of the purchase, defaults to None
+    :type id_: str, optional
+    :param package_id: ID of the package, defaults to None
+    :type package_id: str, optional
+    :param start_date: Start date of the package's validity in the format 'yyyy-MM-ddThh:mm:ssZZ', defaults to None
+    :type start_date: str, optional
+    :param end_date: End date of the package's validity in the format 'yyyy-MM-ddThh:mm:ssZZ', defaults to None
+    :type end_date: str, optional
+    :param created_date: Creation date of the purchase in the format 'yyyy-MM-ddThh:mm:ssZZ', defaults to None
+    :type created_date: str, optional
+    :param start_time: Epoch value representing the start time of the package's validity, defaults to None
+    :type start_time: float, optional
+    :param end_time: Epoch value representing the end time of the package's validity, defaults to None
+    :type end_time: float, optional
+    """
+
+    def __init__(
+        self,
+        id_: str = None,
+        package_id: str = None,
+        start_date: str = None,
+        end_date: str = None,
+        created_date: str = None,
+        start_time: float = None,
+        end_time: float = None,
+    ):
+        self.id_ = id_
+        self.package_id = package_id
+        self.start_date = start_date
+        self.end_date = end_date
+        self.created_date = created_date
+        self.start_time = start_time
+        self.end_time = end_time
+
+
+@JsonMap({"activation_code": "activationCode"})
+class CreatePurchaseOkResponseProfile(BaseModel):
+    """CreatePurchaseOkResponseProfile
+
+    :param iccid: ID of the eSIM, defaults to None
+    :type iccid: str, optional
+    :param activation_code: QR Code of the eSIM as base64, defaults to None
+    :type activation_code: str, optional
+    """
+
+    def __init__(self, iccid: str = None, activation_code: str = None):
+        self.iccid = iccid
+        self.activation_code = activation_code
+
+
+@JsonMap({})
+class CreatePurchaseOkResponse(BaseModel):
+    """CreatePurchaseOkResponse
+
+    :param purchase: purchase, defaults to None
+    :type purchase: CreatePurchaseOkResponsePurchase, optional
+    :param profile: profile, defaults to None
+    :type profile: CreatePurchaseOkResponseProfile, optional
+    """
+
+    def __init__(
+        self,
+        purchase: CreatePurchaseOkResponsePurchase = None,
+        profile: CreatePurchaseOkResponseProfile = None,
+    ):
+        self.purchase = self._define_object(purchase, CreatePurchaseOkResponsePurchase)
+        self.profile = self._define_object(profile, CreatePurchaseOkResponseProfile)

celitech/models/create_purchase_request.py

@@ -0,0 +1,54 @@
+from .utils.json_map import JsonMap
+from .base import BaseModel
+
+
+@JsonMap(
+    {
+        "data_limit_in_gb": "dataLimitInGB",
+        "start_date": "startDate",
+        "end_date": "endDate",
+        "network_brand": "networkBrand",
+        "start_time": "startTime",
+        "end_time": "endTime",
+    }
+)
+class CreatePurchaseRequest(BaseModel):
+    """CreatePurchaseRequest
+
+    :param destination: ISO representation of the package's destination
+    :type destination: str
+    :param data_limit_in_gb: Size of the package in GB. The available options are 1, 2, 3, 5, 8, 20GB
+    :type data_limit_in_gb: float
+    :param start_date: Start date of the package's validity in the format 'yyyy-MM-dd'. This date can be set to the current day or any day within the next 12 months.
+    :type start_date: str
+    :param end_date: End date of the package's validity in the format 'yyyy-MM-dd'. End date can be maximum 60 days after Start date.
+    :type end_date: str
+    :param email: Email address where the purchase confirmation email will be sent (including QR Code & activation steps), defaults to None
+    :type email: str, optional
+    :param network_brand: Customize the network brand of the issued eSIM. This parameter is accessible to platforms with Diamond tier and requires an alphanumeric string of up to 15 characters, defaults to None
+    :type network_brand: str, optional
+    :param start_time: Epoch value representing the start time of the package's validity. This timestamp can be set to the current time or any time within the next 12 months., defaults to None
+    :type start_time: float, optional
+    :param end_time: Epoch value representing the end time of the package's validity. End time can be maximum 60 days after Start time., defaults to None
+    :type end_time: float, optional
+    """
+
+    def __init__(
+        self,
+        destination: str,
+        data_limit_in_gb: float,
+        start_date: str,
+        end_date: str,
+        email: str = None,
+        network_brand: str = None,
+        start_time: float = None,
+        end_time: float = None,
+    ):
+        self.destination = destination
+        self.data_limit_in_gb = data_limit_in_gb
+        self.start_date = start_date
+        self.end_date = end_date
+        self.email = email
+        self.network_brand = network_brand
+        self.start_time = start_time
+        self.end_time = end_time

celitech/models/edit_purchase_ok_response.py

@@ -0,0 +1,41 @@
+from .utils.json_map import JsonMap
+from .base import BaseModel
+
+
+@JsonMap(
+    {
+        "purchase_id": "purchaseId",
+        "new_start_date": "newStartDate",
+        "new_end_date": "newEndDate",
+        "new_start_time": "newStartTime",
+        "new_end_time": "newEndTime",
+    }
+)
+class EditPurchaseOkResponse(BaseModel):
+    """EditPurchaseOkResponse
+
+    :param purchase_id: ID of the purchase, defaults to None
+    :type purchase_id: str, optional
+    :param new_start_date: Start date of the package's validity in the format 'yyyy-MM-ddThh:mm:ssZZ', defaults to None
+    :type new_start_date: str, optional
+    :param new_end_date: End date of the package's validity in the format 'yyyy-MM-ddThh:mm:ssZZ', defaults to None
+    :type new_end_date: str, optional
+    :param new_start_time: Epoch value representing the new start time of the package's validity, defaults to None
+    :type new_start_time: float, optional
+    :param new_end_time: Epoch value representing the new end time of the package's validity, defaults to None
+    :type new_end_time: float, optional
+    """
+
+    def __init__(
+        self,
+        purchase_id: str = None,
+        new_start_date: str = None,
+        new_end_date: str = None,
+        new_start_time: float = None,
+        new_end_time: float = None,
+    ):
+        self.purchase_id = purchase_id
+        self.new_start_date = new_start_date
+        self.new_end_date = new_end_date
+        self.new_start_time = new_start_time
+        self.new_end_time = new_end_time

celitech/models/edit_purchase_request.py

@@ -0,0 +1,41 @@
+from .utils.json_map import JsonMap
+from .base import BaseModel
+
+
+@JsonMap(
+    {
+        "purchase_id": "purchaseId",
+        "start_date": "startDate",
+        "end_date": "endDate",
+        "start_time": "startTime",
+        "end_time": "endTime",
+    }
+)
+class EditPurchaseRequest(BaseModel):
+    """EditPurchaseRequest
+
+    :param purchase_id: ID of the purchase
+    :type purchase_id: str
+    :param start_date: Start date of the package's validity in the format 'yyyy-MM-dd'. This date can be set to the current day or any day within the next 12 months.
+    :type start_date: str
+    :param end_date: End date of the package's validity in the format 'yyyy-MM-dd'. End date can be maximum 60 days after Start date.
+    :type end_date: str
+    :param start_time: Epoch value representing the start time of the package's validity. This timestamp can be set to the current time or any time within the next 12 months., defaults to None
+    :type start_time: float, optional
+    :param end_time: Epoch value representing the end time of the package's validity. End time can be maximum 60 days after Start time., defaults to None
+    :type end_time: float, optional
+    """
+
+    def __init__(
+        self,
+        purchase_id: str,
+        start_date: str,
+        end_date: str,
+        start_time: float = None,
+        end_time: float = None,
+    ):
+        self.purchase_id = purchase_id
+        self.start_date = start_date
+        self.end_date = end_date
+        self.start_time = start_time
+        self.end_time = end_time

celitech/models/get_esim_device_ok_response.py

@@ -0,0 +1,41 @@
+from .utils.json_map import JsonMap
+from .base import BaseModel
+
+
+@JsonMap({"hardware_name": "hardwareName", "hardware_model": "hardwareModel"})
+class Device(BaseModel):
+    """Device
+
+    :param oem: Name of the OEM, defaults to None
+    :type oem: str, optional
+    :param hardware_name: Name of the Device, defaults to None
+    :type hardware_name: str, optional
+    :param hardware_model: Model of the Device, defaults to None
+    :type hardware_model: str, optional
+    :param eid: Serial Number of the eSIM, defaults to None
+    :type eid: str, optional
+    """
+
+    def __init__(
+        self,
+        oem: str = None,
+        hardware_name: str = None,
+        hardware_model: str = None,
+        eid: str = None,
+    ):
+        self.oem = oem
+        self.hardware_name = hardware_name
+        self.hardware_model = hardware_model
+        self.eid = eid
+
+
+@JsonMap({})
+class GetEsimDeviceOkResponse(BaseModel):
+    """GetEsimDeviceOkResponse
+
+    :param device: device, defaults to None
+    :type device: Device, optional
+    """
+
+    def __init__(self, device: Device = None):
+        self.device = self._define_object(device, Device)

celitech/models/get_esim_history_ok_response.py

@@ -0,0 +1,50 @@
+from typing import List
+from .utils.json_map import JsonMap
+from .base import BaseModel
+
+
+@JsonMap({"status_date": "statusDate", "date_": "date"})
+class History(BaseModel):
+    """History
+
+    :param status: The status of the eSIM at a given time, possible values are 'RELEASED', 'DOWNLOADED', 'INSTALLED', 'ENABLED', 'DELETED', or 'ERROR', defaults to None
+    :type status: str, optional
+    :param status_date: The date when the eSIM status changed in the format 'yyyy-MM-ddThh:mm:ssZZ', defaults to None
+    :type status_date: str, optional
+    :param date_: Epoch value representing the date when the eSIM status changed, defaults to None
+    :type date_: float, optional
+    """
+
+    def __init__(
+        self, status: str = None, status_date: str = None, date_: float = None
+    ):
+        self.status = status
+        self.status_date = status_date
+        self.date_ = date_
+
+
+@JsonMap({})
+class GetEsimHistoryOkResponseEsim(BaseModel):
+    """GetEsimHistoryOkResponseEsim
+
+    :param iccid: ID of the eSIM, defaults to None
+    :type iccid: str, optional
+    :param history: history, defaults to None
+    :type history: List[History], optional
+    """
+
+    def __init__(self, iccid: str = None, history: List[History] = None):
+        self.iccid = iccid
+        self.history = self._define_list(history, History)
+
+
+@JsonMap({})
+class GetEsimHistoryOkResponse(BaseModel):
+    """GetEsimHistoryOkResponse
+
+    :param esim: esim, defaults to None
+    :type esim: GetEsimHistoryOkResponseEsim, optional
+    """
+
+    def __init__(self, esim: GetEsimHistoryOkResponseEsim = None):
+        self.esim = self._define_object(esim, GetEsimHistoryOkResponseEsim)