airalo-sdk 1.0.0__py3-none-any.whl

airalo/resources/multi_http_resource.py

@@ -0,0 +1,312 @@
+"""
+Multi HTTP Resource Module
+
+This module provides concurrent HTTP request functionality using ThreadPoolExecutor.
+"""
+
+import concurrent.futures
+import json
+import ssl
+import urllib.error
+import urllib.parse
+import urllib.request
+from typing import Any, Dict, List, Optional, Tuple, Union
+
+from ..config import Config
+from ..constants.sdk_constants import SdkConstants
+from ..exceptions.airalo_exception import NetworkError
+
+
+class MultiHttpResource:
+    """
+    Concurrent HTTP client for making multiple API requests in parallel.
+
+    Uses ThreadPoolExecutor for concurrent request execution.
+    """
+
+    def __init__(self, config: Config):
+        """
+        Initialize multi HTTP resource.
+
+        Args:
+            config: SDK configuration
+        """
+        self._config = config
+        self._handlers: List[Dict[str, Any]] = []
+        self._headers: Dict[str, str] = {}
+        self._options: Dict[str, Any] = {}
+        self._ignore_ssl = False
+        self._timeout = SdkConstants.DEFAULT_TIMEOUT
+        self._tag: Optional[str] = None
+        self._max_workers = SdkConstants.MAX_CONCURRENT_REQUESTS
+
+        # Default headers
+        self._default_headers: Dict[str, str] = {
+            "User-Agent": f"Airalo-Python-SDK/{SdkConstants.VERSION}",
+            "airalo-python-sdk": f"{SdkConstants.VERSION}",
+            "Accept": "application/json",
+            "Content-Type": "application/json",
+        }
+
+    def add(self, method_name: str, args: List[Any]) -> "MultiHttpResource":
+        """
+        Add a request to the queue.
+
+        Args:
+            method_name: HTTP method name ('get', 'post', 'head')
+            args: Method arguments [url, params]
+
+        Returns:
+            Self for method chaining
+        """
+        from .http_resource import HttpResource
+
+        # Create HTTP resource for this request
+        http_resource = HttpResource(self._config, get_handler=True)
+
+        if self._ignore_ssl:
+            http_resource.ignore_ssl()
+
+        if self._timeout != SdkConstants.DEFAULT_TIMEOUT:
+            http_resource.set_timeout(self._timeout)
+
+        if self._headers:
+            http_resource.set_headers(self._headers)
+
+        # Get the method and create request
+        method = getattr(http_resource, method_name)
+        request = method(*args)
+
+        # Store request with metadata
+        handler = {
+            "request": request,
+            "tag": self._tag if self._tag else len(self._handlers),
+            "options": self._options.copy(),
+            "ignore_ssl": self._ignore_ssl,
+            "timeout": self._timeout,
+            "headers": self._merge_headers(),
+        }
+
+        self._handlers.append(handler)
+        self._tag = None
+
+        return self
+
+    def get(
+        self, url: str, params: Optional[Dict[str, Any]] = None
+    ) -> "MultiHttpResource":
+        """
+        Add GET request to queue.
+
+        Args:
+            url: Request URL
+            params: Query parameters
+
+        Returns:
+            Self for method chaining
+        """
+        return self.add("get", [url, params])
+
+    def post(
+        self, url: str, params: Optional[Union[Dict[str, Any], str]] = None
+    ) -> "MultiHttpResource":
+        """
+        Add POST request to queue.
+
+        Args:
+            url: Request URL
+            params: Request body
+
+        Returns:
+            Self for method chaining
+        """
+        return self.add("post", [url, params])
+
+    def tag(self, name: str = "") -> "MultiHttpResource":
+        """
+        Set tag for next request.
+
+        Args:
+            name: Tag name
+
+        Returns:
+            Self for method chaining
+        """
+        if name:
+            self._tag = name
+        return self
+
+    def set_headers(
+        self, headers: Union[Dict[str, str], List[str]]
+    ) -> "MultiHttpResource":
+        """
+        Set headers for all requests.
+
+        Args:
+            headers: Request headers
+
+        Returns:
+            Self for method chaining
+        """
+        if isinstance(headers, list):
+            # Parse list of header strings
+            for header in headers:
+                if ":" in header:
+                    key, value = header.split(":", 1)
+                    self._headers[key.strip()] = value.strip()
+        else:
+            self._headers.update(headers)
+
+        return self
+
+    def set_timeout(self, timeout: int = 30) -> "MultiHttpResource":
+        """
+        Set timeout for all requests.
+
+        Args:
+            timeout: Timeout in seconds
+
+        Returns:
+            Self for method chaining
+        """
+        self._timeout = timeout
+        return self
+
+    def ignore_ssl(self) -> "MultiHttpResource":
+        """
+        Ignore SSL verification for all requests.
+
+        Returns:
+            Self for method chaining
+        """
+        self._ignore_ssl = True
+        return self
+
+    def setopt(self, options: Dict[str, Any]) -> "MultiHttpResource":
+        """
+        Set additional options for requests.
+
+        Args:
+            options: Request options
+
+        Returns:
+            Self for method chaining
+        """
+        self._options = options
+        return self
+
+    def exec(self) -> Dict[Union[str, int], str]:
+        """
+        Execute all queued requests concurrently.
+
+        Returns:
+            Dictionary mapping tags to response bodies
+        """
+        if not self._handlers:
+            return {}
+
+        responses = {}
+
+        # Use ThreadPoolExecutor for concurrent execution
+        with concurrent.futures.ThreadPoolExecutor(
+            max_workers=self._max_workers
+        ) as executor:
+            # Submit all requests
+            future_to_tag = {}
+            for handler in self._handlers:
+                future = executor.submit(self._execute_request, handler)
+                future_to_tag[future] = handler["tag"]
+
+            # Collect results
+            for future in concurrent.futures.as_completed(future_to_tag):
+                tag = future_to_tag[future]
+                try:
+                    response = future.result()
+                    responses[tag] = response
+                except Exception as e:
+                    # Store error as response
+                    responses[tag] = json.dumps(
+                        {"error": str(e), "type": type(e).__name__}
+                    )
+
+        # Clear handlers after execution
+        self._handlers = []
+        self._headers = {}
+        self._options = {}
+        self._ignore_ssl = False
+        self._timeout = SdkConstants.DEFAULT_TIMEOUT
+
+        return responses
+
+    def _execute_request(self, handler: Dict[str, Any]) -> str:
+        """
+        Execute a single request.
+
+        Args:
+            handler: Request handler dictionary
+
+        Returns:
+            Response body
+
+        Raises:
+            NetworkError: If request fails
+        """
+        request = handler["request"]
+
+        # Apply headers
+        if isinstance(request, urllib.request.Request):
+            for key, value in handler["headers"].items():
+                request.add_header(key, value)
+
+        # Configure SSL context
+        context = None
+        if handler["ignore_ssl"]:
+            context = ssl.create_default_context()
+            context.check_hostname = False
+            context.verify_mode = ssl.CERT_NONE
+
+        try:
+            # Execute request
+            response = urllib.request.urlopen(
+                request, timeout=handler["timeout"], context=context
+            )
+
+            # Read and return response
+            return response.read().decode("utf-8")
+
+        except urllib.error.HTTPError as e:
+            # Try to read error response
+            try:
+                return e.read().decode("utf-8")
+            except:
+                raise NetworkError(f"HTTP {e.code}: {e.reason}", http_status=e.code)
+
+        except urllib.error.URLError as e:
+            raise NetworkError(f"Network error: {e.reason}")
+
+        except Exception as e:
+            raise NetworkError(f"Request failed: {str(e)}")
+
+    def _merge_headers(self) -> Dict[str, str]:
+        """
+        Merge default, config, and request headers.
+
+        Returns:
+            Merged headers dictionary
+        """
+        headers = self._default_headers.copy()
+
+        # Add config headers
+        config_headers = self._config.get_http_headers()
+        if isinstance(config_headers, list):
+            for header in config_headers:
+                if ":" in header:
+                    key, value = header.split(":", 1)
+                    headers[key.strip()] = value.strip()
+        elif isinstance(config_headers, dict):
+            headers.update(config_headers)
+
+        # Add request-specific headers
+        headers.update(self._headers)
+
+        return headers

airalo/services/__init__.py

@@ -0,0 +1,17 @@
+"""
+Service classes for Airalo SDK.
+"""
+
+from .oauth_service import OAuthService
+from .packages_service import PackagesService
+from .order_service import OrderService
+from .installation_instructions_service import InstallationInstructionsService
+from .topup_service import TopupService
+
+__all__ = [
+    "OAuthService",
+    "PackagesService",
+    "OrderService",
+    "TopupService",
+    "InstallationInstructionsService",
+]

airalo/services/compatibility_devices_service.py

@@ -0,0 +1,34 @@
+import json
+from typing import Optional, Dict, Any
+from ..constants.api_constants import ApiConstants
+from airalo.exceptions import AiraloException
+
+
+class CompatibilityDevicesService:
+    def __init__(self, config, curl, access_token: str):
+        if not access_token:
+            raise AiraloException("Invalid access token, please check your credentials")
+
+        self.config = config
+        self.curl = curl
+        self.access_token = access_token
+        self.base_url = self.config.get_url()
+
+    def get_compatible_devices(self) -> Optional[Dict[str, Any]]:
+        url = self._build_url()
+
+        headers = {
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {self.access_token}",
+        }
+
+        response = self.curl.set_headers(headers).get(url)
+        result = json.loads(response)
+
+        if result.get("data"):
+            return result
+        else:
+            return None
+
+    def _build_url(self) -> str:
+        return f"{self.base_url}{ApiConstants.COMPATIBILITY_SLUG}"

airalo/services/exchange_rates_service.py

@@ -0,0 +1,69 @@
+import json
+import hashlib
+import re
+from urllib.parse import urlencode
+
+from airalo.resources.http_resource import HttpResource
+from airalo.helpers.date_helper import DateHelper
+from airalo.exceptions import AiraloException
+from airalo.helpers.cached import Cached
+from airalo.constants.api_constants import ApiConstants
+
+
+class ExchangeRatesService:
+    def __init__(self, config, curl: HttpResource, access_token: str):
+        if not access_token:
+            raise AiraloException("Invalid access token, please check your credentials")
+
+        self.config = config
+        self.curl = curl
+        self.access_token = access_token
+        self.base_url = self.config.get_url()
+
+    def exchange_rates(self, params: dict = None):
+        if params is None:
+            params = {}
+
+        self.validate_exchange_rates_request(params)
+        url = self.build_url(params)
+
+        def fetch_data():
+            response = self.curl.set_headers(
+                {
+                    "Accept": "application/json",
+                    "Authorization": f"Bearer {self.access_token}",
+                }
+            ).get(url)
+            return json.loads(response)
+
+        result = Cached.get(fetch_data, self.get_key(url, params), 300)
+
+        return result if result and result.get("data") else None
+
+    def validate_exchange_rates_request(self, params: dict) -> None:
+        if "date" in params and params["date"]:
+            if not DateHelper.validate_date(params["date"]):
+                raise AiraloException(
+                    "Please enter a valid date in the format YYYY-MM-DD"
+                )
+
+        if "to" in params and params["to"]:
+            if not re.match(r"^([A-Za-z]{3})(?:,([A-Za-z]{3}))*$", params["to"]):
+                raise AiraloException(
+                    "Please enter a comma separated list of currency codes. Each code must have 3 letters"
+                )
+
+    def build_url(self, params: dict) -> str:
+        query_params = {}
+
+        if "date" in params and params["date"]:
+            query_params["date"] = params["date"]
+        if "to" in params and params["to"]:
+            query_params["to"] = params["to"]
+
+        return f"{self.base_url}{ApiConstants.EXCHANGE_RATES_SLUG}?{urlencode(query_params)}"
+
+    def get_key(self, url: str, params: dict) -> str:
+        headers = self.config.get_http_headers()
+        raw_key = f"{url}{json.dumps(params, sort_keys=True)}{json.dumps(headers)}{self.access_token}"
+        return hashlib.md5(raw_key.encode()).hexdigest()

airalo/services/future_order_service.py

@@ -0,0 +1,113 @@
+import json
+from datetime import datetime
+
+from ..config import Config
+from ..helpers.signature import Signature
+from ..exceptions.airalo_exception import AiraloException
+from ..resources.http_resource import HttpResource
+from ..constants.api_constants import ApiConstants
+from ..constants.sdk_constants import SdkConstants
+from ..helpers.cloud_sim_share_validator import CloudSimShareValidator
+
+
+class FutureOrderService:
+    def __init__(
+        self,
+        config: Config,
+        http_resource: HttpResource,
+        signature: Signature,
+        access_token: str,
+    ):
+        if not access_token:
+            raise AiraloException(
+                "Invalid access token, please check your credentials."
+            )
+
+        self.config = config
+        self.http = http_resource
+        self.signature = signature
+        self.access_token = access_token
+        self.base_url = self.config.get_url()
+
+    def create_future_order(self, payload: dict) -> dict:
+        self._validate_future_order(payload)
+        self._validate_cloud_sim_share(payload)
+
+        payload = {k: v for k, v in payload.items() if v}
+
+        url = self.base_url + ApiConstants.FUTURE_ORDERS
+        headers = self._get_headers(payload)
+
+        response = self.http.set_headers(headers).post(url, payload)
+
+        if self.http.code != 200:
+            raise AiraloException(
+                f"Future order creation failed, status code: {self.http.code}, response: {response}"
+            )
+
+        return json.loads(response)
+
+    def cancel_future_order(self, payload: dict) -> dict:
+        self._validate_cancel_future_order(payload)
+
+        url = self.base_url + ApiConstants.CANCEL_FUTURE_ORDERS
+        headers = self._get_headers(payload)
+
+        response = self.http.set_headers(headers).post(url, payload)
+
+        if self.http.code != 200:
+            raise AiraloException(
+                f"Future order cancellation failed, status code: {self.http.code}, response: {response}"
+            )
+
+        return json.loads(response)
+
+    def _get_headers(self, payload: dict) -> dict:
+        return {
+            "Authorization": f"Bearer {self.access_token}",
+            "Content-Type": "application/json",
+            "airalo-signature": self.signature.get_signature(payload),
+        }
+
+    def _validate_future_order(self, payload: dict) -> None:
+        if not payload.get("package_id"):
+            raise AiraloException(
+                f"The package_id is required, payload: {json.dumps(payload)}"
+            )
+
+        if payload.get("quantity", 0) < 1:
+            raise AiraloException(
+                f"The quantity is required, payload: {json.dumps(payload)}"
+            )
+
+        if payload["quantity"] > SdkConstants.FUTURE_ORDER_LIMIT:
+            raise AiraloException(
+                f"The packages count may not be greater than {SdkConstants.BULK_ORDER_LIMIT}"
+            )
+
+        due_date = payload.get("due_date")
+        if not due_date:
+            raise AiraloException(
+                f"The due_date is required (format: Y-m-d H:i), payload: {json.dumps(payload)}"
+            )
+
+        try:
+            parsed_date = datetime.strptime(due_date, "%Y-%m-%d %H:%M")
+            if parsed_date.strftime("%Y-%m-%d %H:%M") != due_date:
+                raise ValueError()
+        except ValueError:
+            raise AiraloException(
+                f"The due_date must be in the format Y-m-d H:i, payload: {json.dumps(payload)}"
+            )
+
+    def _validate_cancel_future_order(self, payload: dict) -> None:
+        if (
+            not isinstance(payload.get("request_ids"), list)
+            or not payload["request_ids"]
+        ):
+            raise AiraloException(
+                f"The request_ids is required, payload: {json.dumps(payload)}"
+            )
+
+    def _validate_cloud_sim_share(self, sim_cloud_share: dict) -> None:
+        CloudSimShareValidator.validate(sim_cloud_share)

airalo/services/installation_instructions_service.py

@@ -0,0 +1,63 @@
+import json
+import hashlib
+
+from typing import Optional, Dict, Any
+from ..config import Config
+from ..constants.api_constants import ApiConstants
+from ..constants.sdk_constants import SdkConstants
+from ..helpers.cached import Cached
+from ..resources.http_resource import HttpResource
+from ..exceptions.airalo_exception import AiraloException
+
+
+class InstallationInstructionsService:
+    def __init__(self, config, curl: HttpResource, access_token: str):
+        if not access_token:
+            raise AiraloException("Invalid access token please check your credentials")
+
+        self.config = config
+        self.curl = curl
+        self.access_token = access_token
+        self.base_url = self.config.get_url()
+
+    def get_instructions(self, params=None) -> Optional[Dict[str, Any]]:
+        if params is None:
+            params = {}
+
+        url = self._build_url(params)
+
+        result = Cached.get(
+            lambda: self._fetch(url, params),
+            self._get_key(url, params),
+            SdkConstants.DEFAULT_CACHE_TTL,
+        )
+
+        if result and result["data"]:
+            return result
+        return None
+
+    def _fetch(self, url, params):
+        headers = {
+            "Authorization": f"Bearer {self.access_token}",
+            "Accept-Language": params.get("language", ""),
+        }
+        response = self.curl.set_headers(headers).get(url)
+        result = json.loads(response)
+        return result
+
+    def _build_url(self, params):
+        if "iccid" not in params:
+            raise AiraloException('The parameter "iccid" is required.')
+
+        iccid = str(params["iccid"])
+        url = f"{self.base_url}{ApiConstants.SIMS_SLUG}/{iccid}/{ApiConstants.INSTRUCTIONS_SLUG}"
+        return url
+
+    def _get_key(self, url, params):
+        data = (
+            url
+            + json.dumps(params)
+            + json.dumps(self.config.get_http_headers())
+            + self.access_token
+        )
+        return hashlib.md5(data.encode("utf-8")).hexdigest()