celitech-sdk 1.0.0__py3-none-any.whl

celitech/models/get_esim_mac_ok_response.py

@@ -0,0 +1,39 @@
+from .utils.json_map import JsonMap
+from .base import BaseModel
+
+
+@JsonMap(
+    {"smdp_address": "smdpAddress", "manual_activation_code": "manualActivationCode"}
+)
+class GetEsimMacOkResponseEsim(BaseModel):
+    """GetEsimMacOkResponseEsim
+
+    :param iccid: ID of the eSIM, defaults to None
+    :type iccid: str, optional
+    :param smdp_address: SM-DP+ Address, defaults to None
+    :type smdp_address: str, optional
+    :param manual_activation_code: The manual activation code, defaults to None
+    :type manual_activation_code: str, optional
+    """
+
+    def __init__(
+        self,
+        iccid: str = None,
+        smdp_address: str = None,
+        manual_activation_code: str = None,
+    ):
+        self.iccid = iccid
+        self.smdp_address = smdp_address
+        self.manual_activation_code = manual_activation_code
+
+
+@JsonMap({})
+class GetEsimMacOkResponse(BaseModel):
+    """GetEsimMacOkResponse
+
+    :param esim: esim, defaults to None
+    :type esim: GetEsimMacOkResponseEsim, optional
+    """
+
+    def __init__(self, esim: GetEsimMacOkResponseEsim = None):
+        self.esim = self._define_object(esim, GetEsimMacOkResponseEsim)

celitech/models/get_esim_ok_response.py

@@ -0,0 +1,43 @@
+from .utils.json_map import JsonMap
+from .base import BaseModel
+
+
+@JsonMap(
+    {"smdp_address": "smdpAddress", "manual_activation_code": "manualActivationCode"}
+)
+class GetEsimOkResponseEsim(BaseModel):
+    """GetEsimOkResponseEsim
+
+    :param iccid: ID of the eSIM, defaults to None
+    :type iccid: str, optional
+    :param smdp_address: SM-DP+ Address, defaults to None
+    :type smdp_address: str, optional
+    :param manual_activation_code: The manual activation code, defaults to None
+    :type manual_activation_code: str, optional
+    :param status: Status of the eSIM, possible values are 'RELEASED', 'DOWNLOADED', 'INSTALLED', 'ENABLED', 'DELETED', or 'ERROR', defaults to None
+    :type status: str, optional
+    """
+
+    def __init__(
+        self,
+        iccid: str = None,
+        smdp_address: str = None,
+        manual_activation_code: str = None,
+        status: str = None,
+    ):
+        self.iccid = iccid
+        self.smdp_address = smdp_address
+        self.manual_activation_code = manual_activation_code
+        self.status = status
+
+
+@JsonMap({})
+class GetEsimOkResponse(BaseModel):
+    """GetEsimOkResponse
+
+    :param esim: esim, defaults to None
+    :type esim: GetEsimOkResponseEsim, optional
+    """
+
+    def __init__(self, esim: GetEsimOkResponseEsim = None):
+        self.esim = self._define_object(esim, GetEsimOkResponseEsim)

celitech/models/get_purchase_consumption_ok_response.py

@@ -0,0 +1,17 @@
+from .utils.json_map import JsonMap
+from .base import BaseModel
+
+
+@JsonMap({"data_usage_remaining_in_bytes": "dataUsageRemainingInBytes"})
+class GetPurchaseConsumptionOkResponse(BaseModel):
+    """GetPurchaseConsumptionOkResponse
+
+    :param data_usage_remaining_in_bytes: Remaining balance of the package in bytes, defaults to None
+    :type data_usage_remaining_in_bytes: float, optional
+    :param status: Status of the connectivity, possible values are 'ACTIVE' or 'NOT_ACTIVE', defaults to None
+    :type status: str, optional
+    """
+
+    def __init__(self, data_usage_remaining_in_bytes: float = None, status: str = None):
+        self.data_usage_remaining_in_bytes = data_usage_remaining_in_bytes
+        self.status = status

celitech/models/list_destinations_ok_response.py

@@ -0,0 +1,38 @@
+from typing import List
+from .utils.json_map import JsonMap
+from .base import BaseModel
+
+
+@JsonMap({"supported_countries": "supportedCountries"})
+class Destinations(BaseModel):
+    """Destinations
+
+    :param name: Name of the destination, defaults to None
+    :type name: str, optional
+    :param destination: ISO representation of the destination, defaults to None
+    :type destination: str, optional
+    :param supported_countries: supported_countries, defaults to None
+    :type supported_countries: List[str], optional
+    """
+
+    def __init__(
+        self,
+        name: str = None,
+        destination: str = None,
+        supported_countries: List[str] = None,
+    ):
+        self.name = name
+        self.destination = destination
+        self.supported_countries = supported_countries
+
+
+@JsonMap({})
+class ListDestinationsOkResponse(BaseModel):
+    """ListDestinationsOkResponse
+
+    :param destinations: destinations, defaults to None
+    :type destinations: List[Destinations], optional
+    """
+
+    def __init__(self, destinations: List[Destinations] = None):
+        self.destinations = self._define_list(destinations, Destinations)

celitech/models/list_packages_ok_response.py

@@ -0,0 +1,61 @@
+from typing import List
+from .utils.json_map import JsonMap
+from .base import BaseModel
+
+
+@JsonMap(
+    {
+        "id_": "id",
+        "data_limit_in_bytes": "dataLimitInBytes",
+        "min_days": "minDays",
+        "max_days": "maxDays",
+        "price_in_cents": "priceInCents",
+    }
+)
+class Packages(BaseModel):
+    """Packages
+
+    :param id_: ID of the package, defaults to None
+    :type id_: str, optional
+    :param destination: ISO representation of the package's destination, defaults to None
+    :type destination: str, optional
+    :param data_limit_in_bytes: Size of the package in Bytes, defaults to None
+    :type data_limit_in_bytes: float, optional
+    :param min_days: Min number of days for the package, defaults to None
+    :type min_days: float, optional
+    :param max_days: Max number of days for the package, defaults to None
+    :type max_days: float, optional
+    :param price_in_cents: Price of the package in cents, defaults to None
+    :type price_in_cents: float, optional
+    """
+
+    def __init__(
+        self,
+        id_: str = None,
+        destination: str = None,
+        data_limit_in_bytes: float = None,
+        min_days: float = None,
+        max_days: float = None,
+        price_in_cents: float = None,
+    ):
+        self.id_ = id_
+        self.destination = destination
+        self.data_limit_in_bytes = data_limit_in_bytes
+        self.min_days = min_days
+        self.max_days = max_days
+        self.price_in_cents = price_in_cents
+
+
+@JsonMap({"after_cursor": "afterCursor"})
+class ListPackagesOkResponse(BaseModel):
+    """ListPackagesOkResponse
+
+    :param packages: packages, defaults to None
+    :type packages: List[Packages], optional
+    :param after_cursor: The cursor value representing the end of the current page of results. Use this cursor value as the "afterCursor" parameter in your next request to retrieve the subsequent page of results. It ensures that you continue fetching data from where you left off, facilitating smooth pagination, defaults to None
+    :type after_cursor: str, optional
+    """
+
+    def __init__(self, packages: List[Packages] = None, after_cursor: str = None):
+        self.packages = self._define_list(packages, Packages)
+        self.after_cursor = after_cursor

celitech/models/list_purchases_ok_response.py

@@ -0,0 +1,129 @@
+from typing import List
+from .utils.json_map import JsonMap
+from .base import BaseModel
+
+
+@JsonMap(
+    {
+        "id_": "id",
+        "data_limit_in_bytes": "dataLimitInBytes",
+        "destination_name": "destinationName",
+        "price_in_cents": "priceInCents",
+    }
+)
+class Package(BaseModel):
+    """Package
+
+    :param id_: ID of the package, defaults to None
+    :type id_: str, optional
+    :param data_limit_in_bytes: Size of the package in Bytes, defaults to None
+    :type data_limit_in_bytes: float, optional
+    :param destination: ISO representation of the package's destination, defaults to None
+    :type destination: str, optional
+    :param destination_name: Name of the package's destination, defaults to None
+    :type destination_name: str, optional
+    :param price_in_cents: Price of the package in cents, defaults to None
+    :type price_in_cents: float, optional
+    """
+
+    def __init__(
+        self,
+        id_: str = None,
+        data_limit_in_bytes: float = None,
+        destination: str = None,
+        destination_name: str = None,
+        price_in_cents: float = None,
+    ):
+        self.id_ = id_
+        self.data_limit_in_bytes = data_limit_in_bytes
+        self.destination = destination
+        self.destination_name = destination_name
+        self.price_in_cents = price_in_cents
+
+
+@JsonMap({})
+class PurchasesEsim(BaseModel):
+    """PurchasesEsim
+
+    :param iccid: ID of the eSIM, defaults to None
+    :type iccid: str, optional
+    """
+
+    def __init__(self, iccid: str = None):
+        self.iccid = iccid
+
+
+@JsonMap(
+    {
+        "id_": "id",
+        "start_date": "startDate",
+        "end_date": "endDate",
+        "created_date": "createdDate",
+        "start_time": "startTime",
+        "end_time": "endTime",
+        "created_at": "createdAt",
+    }
+)
+class Purchases(BaseModel):
+    """Purchases
+
+    :param id_: ID of the purchase, defaults to None
+    :type 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
+    :param created_at: Epoch value representing the date of creation of the purchase, defaults to None
+    :type created_at: float, optional
+    :param package: package, defaults to None
+    :type package: Package, optional
+    :param esim: esim, defaults to None
+    :type esim: PurchasesEsim, optional
+    :param source: The source indicates where the eSIM was purchased, which can be from the API, dashboard, or landing-page. For purchases made before September 8, 2023, the value will be displayed as 'Not available'., defaults to None
+    :type source: str, optional
+    """
+
+    def __init__(
+        self,
+        id_: str = None,
+        start_date: str = None,
+        end_date: str = None,
+        created_date: str = None,
+        start_time: float = None,
+        end_time: float = None,
+        created_at: float = None,
+        package: Package = None,
+        esim: PurchasesEsim = None,
+        source: str = None,
+    ):
+        self.id_ = 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
+        self.created_at = created_at
+        self.package = self._define_object(package, Package)
+        self.esim = self._define_object(esim, PurchasesEsim)
+        self.source = source
+
+
+@JsonMap({"after_cursor": "afterCursor"})
+class ListPurchasesOkResponse(BaseModel):
+    """ListPurchasesOkResponse
+
+    :param purchases: purchases, defaults to None
+    :type purchases: List[Purchases], optional
+    :param after_cursor: The cursor value representing the end of the current page of results. Use this cursor value as the "afterCursor" parameter in your next request to retrieve the subsequent page of results. It ensures that you continue fetching data from where you left off, facilitating smooth pagination., defaults to None
+    :type after_cursor: str, optional
+    """
+
+    def __init__(self, purchases: List[Purchases] = None, after_cursor: str = None):
+        self.purchases = self._define_list(purchases, Purchases)
+        self.after_cursor = after_cursor

celitech/models/top_up_esim_ok_response.py

@@ -0,0 +1,82 @@
+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 TopUpEsimOkResponsePurchase(BaseModel):
+    """TopUpEsimOkResponsePurchase
+
+    :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({})
+class TopUpEsimOkResponseProfile(BaseModel):
+    """TopUpEsimOkResponseProfile
+
+    :param iccid: ID of the eSIM, defaults to None
+    :type iccid: str, optional
+    """
+
+    def __init__(self, iccid: str = None):
+        self.iccid = iccid
+
+
+@JsonMap({})
+class TopUpEsimOkResponse(BaseModel):
+    """TopUpEsimOkResponse
+
+    :param purchase: purchase, defaults to None
+    :type purchase: TopUpEsimOkResponsePurchase, optional
+    :param profile: profile, defaults to None
+    :type profile: TopUpEsimOkResponseProfile, optional
+    """
+
+    def __init__(
+        self,
+        purchase: TopUpEsimOkResponsePurchase = None,
+        profile: TopUpEsimOkResponseProfile = None,
+    ):
+        self.purchase = self._define_object(purchase, TopUpEsimOkResponsePurchase)
+        self.profile = self._define_object(profile, TopUpEsimOkResponseProfile)

celitech/models/top_up_esim_request.py

@@ -0,0 +1,49 @@
+from .utils.json_map import JsonMap
+from .base import BaseModel
+
+
+@JsonMap(
+    {
+        "data_limit_in_gb": "dataLimitInGB",
+        "start_date": "startDate",
+        "end_date": "endDate",
+        "start_time": "startTime",
+        "end_time": "endTime",
+    }
+)
+class TopUpEsimRequest(BaseModel):
+    """TopUpEsimRequest
+
+    :param iccid: ID of the eSIM
+    :type iccid: 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 (excluding QR Code & activation steps), defaults to None
+    :type email: 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,
+        iccid: str,
+        data_limit_in_gb: float,
+        start_date: str,
+        end_date: str,
+        email: str = None,
+        start_time: float = None,
+        end_time: float = None,
+    ):
+        self.iccid = iccid
+        self.data_limit_in_gb = data_limit_in_gb
+        self.start_date = start_date
+        self.end_date = end_date
+        self.email = email
+        self.start_time = start_time
+        self.end_time = end_time

celitech/models/utils/cast_models.py

@@ -0,0 +1,81 @@
+from enum import Enum
+from typing import get_origin, get_args, Union
+from inspect import isclass
+from ..base import OneOfBaseModel
+
+
+def cast_models(func):
+    """
+    A decorator that allows for the conversion of dictionaries and enum values to model instances.
+
+    :param func: The function to decorate.
+    :type func: Callable
+    :return: The decorated function.
+    :rtype: Callable
+    """
+
+    def wrapper(self, *clss, **kwargs):
+        cls_types = func.__annotations__
+        new_cls_args = []
+        new_kwargs = {}
+
+        for input, input_type in zip(clss, cls_types.values()):
+            new_cls_args.append(_get_instanced_type(input, input_type))
+
+        for type_name, input in kwargs.items():
+            new_kwargs[type_name] = _get_instanced_type(input, cls_types[type_name])
+
+        return func(self, *new_cls_args, **new_kwargs)
+
+    def _get_instanced_type(data, input_type):
+        """
+        Get instanced type based on the input data and type.
+
+        :param data: The input data.
+        :param input_type: The type of the input.
+        :return: The instanced type.
+        """
+        # Instanciate oneOf models
+        if _is_one_of_model(input_type):
+            class_list = {
+                arg.__name__: arg for arg in get_args(input_type) if arg.__name__
+            }
+            OneOfBaseModel.class_list = class_list
+            return OneOfBaseModel.return_one_of(data)
+
+        # Instanciate enum values
+        elif (
+            isclass(input_type)
+            and issubclass(input_type, Enum)
+            and not isinstance(data, input_type)
+        ):
+            return input_type(data)
+
+        # Instanciate object models
+        elif isinstance(data, dict) and input_type is not str:
+            return input_type(**data)
+
+        # Instanciate list of object models
+        elif isinstance(data, list) and all(isinstance(i, dict) for i in data):
+            element_type = get_args(input_type)[0]
+            return [element_type(**item) for item in data]
+
+        # Instanciate bytes if input is str
+        elif input_type is bytes and isinstance(data, str):
+            return data.encode()
+
+        # Pass other types
+        else:
+            return data
+
+    def _is_one_of_model(cls_type):
+        """
+        Check if the class type is a oneOf model.
+
+        :param cls_type: The class type to check.
+        :return: True if the class type is a oneOf model, False otherwise.
+        :rtype: bool
+        """
+        return hasattr(cls_type, "__origin__") and cls_type.__origin__ is Union
+
+    return wrapper

celitech/models/utils/json_map.py

@@ -0,0 +1,80 @@
+from enum import Enum
+
+
+class JsonMap:
+    """
+    A class decorator used to map adjusted attribute names to original JSON attribute names before a request,
+    and vice versa after the request.
+
+    Example:
+    @JsonMapping({
+        'adjusted_name': 'original_name',
+        'adjusted_list': 'original_list'
+    })
+    class SomeClass(BaseModel):
+        adjusted_name: str
+        adjusted_list: List[OtherClass]
+
+    :param mapping: A dictionary specifying the mapping between adjusted attribute names and original JSON attribute names.
+    :type mapping: dict
+    """
+
+    def __init__(self, mapping):
+        self.mapping = mapping
+
+    def __call__(self, cls):
+        """
+        Transform the decorated class with attribute mapping capabilities.
+
+        :param cls: The class to be decorated.
+        :type cls: type
+        :return: The decorated class.
+        :rtype: type
+        """
+        cls.__json_mapping = self.mapping
+
+        def _map(self):
+            """
+            Convert the object's attributes to a dictionary with mapped attribute names.
+
+            :return: A dictionary with mapped attribute names and values.
+            :rtype: dict
+            """
+            map = self.__json_mapping
+            attribute_dict = vars(self)
+            result_dict = {}
+
+            for key, value in attribute_dict.items():
+                if isinstance(value, list):
+                    value = [v._map() if hasattr(v, "_map") else v for v in value]
+                elif isinstance(value, Enum):
+                    value = value.value
+                elif hasattr(value, "_map"):
+                    value = value._map()
+                mapped_key = map.get(key, key)
+                result_dict[mapped_key] = value
+
+            return result_dict
+
+        @classmethod
+        def _unmap(cls, mapped_data):
+            """
+            Create an object instance from a dictionary with mapped attribute names.
+
+            :param mapped_data: A dictionary with mapped attribute names and values.
+            :type mapped_data: dict
+            :return: An instance of the class with attribute values assigned from the dictionary.
+            :rtype: cls
+            """
+            reversed_map = {v: k for k, v in cls.__json_mapping.items()}
+            mapped_attributes = {}
+            for key, value in mapped_data.items():
+                mapped_key = reversed_map.get(key, key)
+                mapped_attributes[mapped_key] = value
+
+            return cls(**mapped_attributes)
+
+        cls._map = _map
+        cls._unmap = _unmap
+
+        return cls

celitech/net/environment/__init__.py

@@ -0,0 +1 @@
+from .environment import Environment

celitech/net/environment/environment.py

@@ -0,0 +1,11 @@
+"""
+An enum class containing all the possible environments for the SDK
+"""
+
+from enum import Enum
+
+
+class Environment(Enum):
+    """The environments available for the SDK"""
+
+    DEFAULT = "https://api.celitech.net/v1"

celitech/net/headers/base_header.py

@@ -0,0 +1,9 @@
+from typing import Any, Dict
+
+
+class BaseHeader:
+    def set_value(self, value: Any) -> None:
+        pass
+
+    def get_headers(self) -> Dict[str, str]:
+        pass