intelion-cloud 0.2.0__py3-none-any.whl

intelion_cloud/exceptions.py

@@ -0,0 +1,92 @@
+"""Exception hierarchy for the Intelion Cloud client."""
+
+from typing import Any, Dict, Optional
+
+__all__ = [
+    "IntelionCloudError",
+    "APIError",
+    "AuthenticationError",
+    "ForbiddenError",
+    "NotFoundError",
+    "ConflictError",
+    "RateLimitError",
+    "ValidationError",
+    "ServerError",
+    "ConnectionError",
+]
+
+
+class IntelionCloudError(Exception):
+    """Base exception for all Intelion Cloud client errors."""
+
+
+class APIError(IntelionCloudError):
+    """Error returned by the Intelion Cloud API."""
+
+    def __init__(
+        self,
+        message: str,
+        *,
+        status_code: int,
+        response_body: Any = None,
+    ) -> None:
+        self.status_code = status_code
+        self.response_body = response_body
+        super().__init__(message)
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}(status_code={self.status_code}, message={str(self)!r})"
+
+
+class AuthenticationError(APIError):
+    """401 Unauthorized — invalid or missing API token."""
+
+
+class ForbiddenError(APIError):
+    """403 Forbidden — insufficient permissions."""
+
+
+class NotFoundError(APIError):
+    """404 Not Found — resource does not exist."""
+
+
+class ConflictError(APIError):
+    """409 Conflict — server is busy with another operation."""
+
+
+class RateLimitError(APIError):
+    """429 Too Many Requests — rate limit exceeded."""
+
+    def __init__(
+        self,
+        message: str,
+        *,
+        status_code: int = 429,
+        response_body: Any = None,
+        retry_after: Optional[float] = None,
+    ) -> None:
+        self.retry_after = retry_after
+        super().__init__(message, status_code=status_code, response_body=response_body)
+
+
+class ValidationError(APIError):
+    """400 Bad Request — validation failed with field-level errors."""
+
+    def __init__(
+        self,
+        message: str,
+        *,
+        status_code: int = 400,
+        response_body: Any = None,
+        field_errors: Optional[Dict[str, Any]] = None,
+    ) -> None:
+        self.field_errors = field_errors or {}
+        super().__init__(message, status_code=status_code, response_body=response_body)
+
+
+class ServerError(APIError):
+    """5xx Server Error — Intelion Cloud API server error."""
+
+
+class ConnectionError(IntelionCloudError):
+    """Network-level error (connection refused, timeout, DNS failure)."""

intelion_cloud/models/__init__.py

@@ -0,0 +1,33 @@
+"""Data models for the Intelion Cloud API."""
+
+from .components import CPU, GPU, OSImage, RAM, SSD
+from .flavors import Flavor
+from .servers import (
+    CloudServer,
+    DebtInfo,
+    PhysicalServer,
+    Promocode,
+    ServerStatus,
+    SoftwareAddonInstance,
+    UsageAct,
+    WhiteIP,
+)
+from .users import User
+
+__all__ = [
+    "GPU",
+    "CPU",
+    "RAM",
+    "SSD",
+    "OSImage",
+    "Flavor",
+    "CloudServer",
+    "DebtInfo",
+    "PhysicalServer",
+    "Promocode",
+    "ServerStatus",
+    "SoftwareAddonInstance",
+    "UsageAct",
+    "WhiteIP",
+    "User",
+]

intelion_cloud/models/_base.py

@@ -0,0 +1,39 @@
+"""Base utilities for model deserialization."""
+
+from __future__ import annotations
+
+from typing import Any, Dict, Optional, Type, TypeVar
+
+T = TypeVar("T")
+
+
+def _get(data: Dict[str, Any], key: str, default: Any = None) -> Any:
+    """Get a value from dict, treating empty string as None."""
+    val = data.get(key, default)
+    if val == "":
+        return default
+    return val
+
+
+def _parse_nested(
+    data: Dict[str, Any],
+    key: str,
+    cls: Type[T],
+) -> Optional[T]:
+    """Parse a nested object from a dict if present and non-null."""
+    val = data.get(key)
+    if val is None or not isinstance(val, dict):
+        return None
+    return cls.from_dict(val)  # type: ignore[attr-defined]
+
+
+def _parse_nested_list(
+    data: Dict[str, Any],
+    key: str,
+    cls: Type[T],
+) -> list:
+    """Parse a list of nested objects."""
+    val = data.get(key)
+    if val is None or not isinstance(val, list):
+        return []
+    return [cls.from_dict(item) for item in val if isinstance(item, dict)]  # type: ignore[attr-defined]

intelion_cloud/models/components.py

@@ -0,0 +1,218 @@
+"""Hardware component models (GPU, CPU, RAM, SSD, OSImage)."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Dict, List, Optional
+
+from ._base import _get
+
+
+@dataclass(frozen=True)
+class GPU:
+    """Graphics processing unit specification."""
+
+    id: int
+    name: str
+    slug: str
+    group_title: str
+    cuda_cores: int
+    tensor_cores: int
+    ram: int
+    ram_type: str
+    is_cloud: bool
+    monthly_price_rub_cents: int
+    hourly_price_rub_cents: int
+    daily_price_rub_cents: int
+    monthly_price_rub: Optional[float] = None
+    hourly_price_rub: Optional[float] = None
+    daily_price_rub: Optional[float] = None
+    old_monthly_price_rub: Optional[float] = None
+    discount_percent: int = 0
+    tmu: Optional[int] = None
+    rop: Optional[int] = None
+    ram_capacity: Optional[int] = None
+    processor: Optional[str] = None
+    cover: Optional[str] = None
+    description: Optional[str] = None
+    l1_cache: Optional[str] = None
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> GPU:
+        return cls(
+            id=data["id"],
+            name=data["name"],
+            slug=data.get("slug", ""),
+            group_title=data.get("group_title", ""),
+            cuda_cores=data.get("cuda_cores", 0),
+            tensor_cores=data.get("tensor_cores", 0),
+            ram=data.get("ram", 0),
+            ram_type=data.get("ram_type", ""),
+            is_cloud=data.get("is_cloud", False),
+            monthly_price_rub_cents=data.get("monthly_price_rub_cents", 0),
+            hourly_price_rub_cents=data.get("hourly_price_rub_cents", 0),
+            daily_price_rub_cents=data.get("daily_price_rub_cents", 0),
+            monthly_price_rub=_get(data, "monthly_price_rub"),
+            hourly_price_rub=_get(data, "hourly_price_rub"),
+            daily_price_rub=_get(data, "daily_price_rub"),
+            old_monthly_price_rub=_get(data, "old_monthly_price_rub"),
+            discount_percent=data.get("discount_percent", 0),
+            tmu=_get(data, "tmu"),
+            rop=_get(data, "rop"),
+            ram_capacity=_get(data, "ram_capacity"),
+            processor=_get(data, "processor"),
+            cover=_get(data, "cover"),
+            description=_get(data, "description"),
+            l1_cache=_get(data, "l1_cache"),
+        )
+
+
+@dataclass(frozen=True)
+class CPU:
+    """CPU specification."""
+
+    id: int
+    name: str
+    cores: int
+    threads: int
+    monthly_price_rub_cents: int
+    hourly_price_rub_cents: int
+    daily_price_rub_cents: int
+    group_title: str = ""
+    freq_base: Optional[float] = None
+    freq_turbo: Optional[float] = None
+    l3_cache: Optional[float] = None
+    ram_channels: Optional[int] = None
+    ram_max_size: Optional[int] = None
+    has_ecc_ram_support: bool = False
+    cover: Optional[str] = None
+    min_count: int = 1
+    max_count: int = 1
+    monthly_price_rub: Optional[float] = None
+    hourly_price_rub: Optional[float] = None
+    daily_price_rub: Optional[float] = None
+    old_monthly_price_rub: Optional[float] = None
+    discount_percent: int = 0
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> CPU:
+        return cls(
+            id=data["id"],
+            name=data["name"],
+            cores=data.get("cores", 0),
+            threads=data.get("threads", 0),
+            monthly_price_rub_cents=data.get("monthly_price_rub_cents", 0),
+            hourly_price_rub_cents=data.get("hourly_price_rub_cents", 0),
+            daily_price_rub_cents=data.get("daily_price_rub_cents", 0),
+            group_title=data.get("group_title", ""),
+            freq_base=_get(data, "freq_base"),
+            freq_turbo=_get(data, "freq_turbo"),
+            l3_cache=_get(data, "l3_cache"),
+            ram_channels=_get(data, "ram_channels"),
+            ram_max_size=_get(data, "ram_max_size"),
+            has_ecc_ram_support=data.get("has_ecc_ram_support", False),
+            cover=_get(data, "cover"),
+            min_count=data.get("min_count", 1),
+            max_count=data.get("max_count", 1),
+            monthly_price_rub=_get(data, "monthly_price_rub"),
+            hourly_price_rub=_get(data, "hourly_price_rub"),
+            daily_price_rub=_get(data, "daily_price_rub"),
+            old_monthly_price_rub=_get(data, "old_monthly_price_rub"),
+            discount_percent=data.get("discount_percent", 0),
+        )
+
+
+@dataclass(frozen=True)
+class RAM:
+    """RAM module specification."""
+
+    id: int
+    size: int
+    is_ecc: bool
+    standard: int
+    monthly_price_rub_cents: int
+    hourly_price_rub_cents: int
+    daily_price_rub_cents: int
+    group_title: str = ""
+    monthly_price_rub: Optional[float] = None
+    hourly_price_rub: Optional[float] = None
+    daily_price_rub: Optional[float] = None
+    old_monthly_price_rub: Optional[float] = None
+    discount_percent: int = 0
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> RAM:
+        return cls(
+            id=data["id"],
+            size=data.get("size", 0),
+            is_ecc=data.get("is_ecc", False),
+            standard=data.get("standard", 4),
+            monthly_price_rub_cents=data.get("monthly_price_rub_cents", 0),
+            hourly_price_rub_cents=data.get("hourly_price_rub_cents", 0),
+            daily_price_rub_cents=data.get("daily_price_rub_cents", 0),
+            group_title=data.get("group_title", ""),
+            monthly_price_rub=_get(data, "monthly_price_rub"),
+            hourly_price_rub=_get(data, "hourly_price_rub"),
+            daily_price_rub=_get(data, "daily_price_rub"),
+            old_monthly_price_rub=_get(data, "old_monthly_price_rub"),
+            discount_percent=data.get("discount_percent", 0),
+        )
+
+
+@dataclass(frozen=True)
+class SSD:
+    """SSD/NVMe drive specification."""
+
+    id: int
+    size: int
+    group_title: str
+    monthly_price_rub_cents: int
+    hourly_price_rub_cents: int
+    daily_price_rub_cents: int
+    monthly_price_rub: Optional[float] = None
+    hourly_price_rub: Optional[float] = None
+    daily_price_rub: Optional[float] = None
+    old_monthly_price_rub: Optional[float] = None
+    discount_percent: int = 0
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> SSD:
+        return cls(
+            id=data["id"],
+            size=data.get("size", 0),
+            group_title=data.get("group_title", ""),
+            monthly_price_rub_cents=data.get("monthly_price_rub_cents", 0),
+            hourly_price_rub_cents=data.get("hourly_price_rub_cents", 0),
+            daily_price_rub_cents=data.get("daily_price_rub_cents", 0),
+            monthly_price_rub=_get(data, "monthly_price_rub"),
+            hourly_price_rub=_get(data, "hourly_price_rub"),
+            daily_price_rub=_get(data, "daily_price_rub"),
+            old_monthly_price_rub=_get(data, "old_monthly_price_rub"),
+            discount_percent=data.get("discount_percent", 0),
+        )
+
+
+
+@dataclass(frozen=True)
+class OSImage:
+    """Operating system image available for server deployment."""
+
+    id: int
+    name: str
+    type: str
+    description: str = ""
+    ssh_enabled: bool = False
+    rdp_enabled: bool = False
+    compatible_flavor_ids: Optional[List[int]] = None
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> OSImage:
+        return cls(
+            id=data["id"],
+            name=data["name"],
+            type=data.get("type", ""),
+            description=data.get("description", ""),
+            ssh_enabled=data.get("ssh_enabled", False),
+            rdp_enabled=data.get("rdp_enabled", False),
+            compatible_flavor_ids=data.get("compatible_flavor_ids"),
+        )

intelion_cloud/models/flavors.py

@@ -0,0 +1,44 @@
+"""Flavor model — server hardware configuration (FlavorConfig)."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Dict, Optional
+
+from ._base import _get, _parse_nested
+from .components import CPU, GPU, RAM
+
+
+@dataclass(frozen=True)
+class Flavor:
+    """A flavor describing a server hardware configuration template (backed by FlavorConfig)."""
+
+    id: int
+    name: str
+    cpu_count: int
+    ram_count: int
+    gpu_count: Optional[int]
+    flavor_monthly_price_rub_cents: int
+    flavor_hourly_price_rub_cents: int
+    max_available: int
+    openstack_id: Optional[str] = None
+    cpu: Optional[CPU] = None
+    ram: Optional[RAM] = None
+    gpu: Optional[GPU] = None
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> Flavor:
+        return cls(
+            id=data["id"],
+            name=data.get("name", ""),
+            cpu_count=data.get("cpu_count", 0),
+            ram_count=data.get("ram_count", 0),
+            gpu_count=_get(data, "gpu_count"),
+            flavor_monthly_price_rub_cents=data.get("flavor_monthly_price_rub_cents", 0),
+            flavor_hourly_price_rub_cents=data.get("flavor_hourly_price_rub_cents", 0),
+            max_available=data.get("max_available", 0),
+            openstack_id=_get(data, "openstack_id"),
+            cpu=_parse_nested(data, "cpu", CPU),
+            ram=_parse_nested(data, "ram", RAM),
+            gpu=_parse_nested(data, "gpu", GPU),
+        )

intelion_cloud/models/servers.py

@@ -0,0 +1,247 @@
+"""Cloud server and related billing models."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any, Dict, List, Optional
+
+from ._base import _get, _parse_nested, _parse_nested_list
+from .components import CPU, GPU, OSImage, RAM, SSD
+
+
+@dataclass(frozen=True)
+class DebtInfo:
+    """Next payment / debt information for a usage act."""
+
+    period_price_rub_cents: int
+    periods_to_pay: int
+    amount_rub_cents: int
+    period_end_dt: Optional[str] = None
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> DebtInfo:
+        return cls(
+            period_price_rub_cents=data.get("period_price_rub_cents", 0),
+            periods_to_pay=data.get("periods_to_pay", 0),
+            amount_rub_cents=data.get("amount_rub_cents", 0),
+            period_end_dt=_get(data, "period_end_dt"),
+        )
+
+
+@dataclass(frozen=True)
+class UsageAct:
+    """A billing period record (snapshot of prices at the time of creation)."""
+
+    id: int
+    user_config_id: int
+    start_dt: Optional[str] = None
+    stop_dt: Optional[str] = None
+    monthly_price_rub: Optional[float] = None
+    daily_price_rub: Optional[float] = None
+    hourly_price_rub: Optional[float] = None
+    period: Optional[int] = None
+    periods_planned: Optional[int] = None
+    cloud_server_uptime_seconds: int = 0
+    cloud_srv_price_rub_cents: int = 0
+    actual_cost_rub_cents: int = 0
+    next_payment: Optional[DebtInfo] = None
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> UsageAct:
+        return cls(
+            id=data["id"],
+            user_config_id=data.get("user_config_id", 0),
+            start_dt=_get(data, "start_dt"),
+            stop_dt=_get(data, "stop_dt"),
+            monthly_price_rub=_get(data, "monthly_price_rub"),
+            daily_price_rub=_get(data, "daily_price_rub"),
+            hourly_price_rub=_get(data, "hourly_price_rub"),
+            period=_get(data, "period"),
+            periods_planned=_get(data, "periods_planned"),
+            cloud_server_uptime_seconds=data.get("cloud_server_uptime_seconds", 0),
+            cloud_srv_price_rub_cents=data.get("cloud_srv_price_rub_cents", 0),
+            actual_cost_rub_cents=data.get("actual_cost_rub_cents", 0),
+            next_payment=_parse_nested(data, "next_payment", DebtInfo),
+        )
+
+
+@dataclass(frozen=True)
+class Promocode:
+    """Applied promotional code."""
+
+    id: int
+    code: str
+    discount_value: int
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> Promocode:
+        return cls(
+            id=data["id"],
+            code=data.get("code", ""),
+            discount_value=data.get("discount_value", 0),
+        )
+
+
+@dataclass(frozen=True)
+class WhiteIP:
+    """A public IP address assigned to a server."""
+
+    address_v4: str
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> WhiteIP:
+        return cls(address_v4=data.get("address_v4", ""))
+
+
+@dataclass(frozen=True)
+class PhysicalServer:
+    """Physical server reference (for dedicated servers only)."""
+
+    name: str
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> PhysicalServer:
+        return cls(name=data.get("name", ""))
+
+
+@dataclass(frozen=True)
+class SoftwareAddonInstance:
+    """Software addon installed (or being installed) on a cloud server."""
+
+    uca_id: int
+    id: int
+    name: str
+    status: str
+    port: Optional[int] = None
+    access_token: str = ""
+    progress_message: str = ""
+    error_message: str = ""
+    hardware_mode: str = ""
+    last_heartbeat_dt: Optional[str] = None
+    has_error: bool = False
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> SoftwareAddonInstance:
+        return cls(
+            uca_id=data["uca_id"],
+            id=data["id"],
+            name=data.get("name", ""),
+            status=data.get("status", ""),
+            port=_get(data, "port"),
+            access_token=data.get("access_token", "") or "",
+            progress_message=data.get("progress_message", "") or "",
+            error_message=data.get("error_message", "") or "",
+            hardware_mode=data.get("hardware_mode", "") or "",
+            last_heartbeat_dt=_get(data, "last_heartbeat_dt"),
+            has_error=data.get("has_error", False),
+        )
+
+
+@dataclass(frozen=True)
+class CloudServer:
+    """A cloud (or dedicated) server configuration.
+
+    This is the main model returned by the cloud-servers API endpoints.
+    Cloud servers have ``flavor_oid`` set; dedicated servers have it as ``None``.
+    """
+
+    id: int
+    name: str
+    status: int
+    price_plan: int
+    is_auto_renewal: bool
+    monthly_price_rub_cents: int
+    hourly_price_rub_cents: int
+    server_full_rent_price_rub_cents: int
+    flavor_oid: Optional[str] = None
+    server_state: int = 0
+    has_instance: bool = False
+    credentials: str = ""
+    ip_to_connect: Optional[str] = None
+    domain_to_connect: Optional[str] = None
+    login: str = ""
+    gpu: Optional[GPU] = None
+    gpu_count: int = 0
+    cpu: Optional[CPU] = None
+    cpu_count: int = 0
+    ram: Optional[RAM] = None
+    ram_count: int = 0
+    network_disk: Optional[SSD] = None
+    network_disk_count: int = 0
+    local_disk: Optional[SSD] = None
+    local_disk_count: int = 0
+    os: Optional[OSImage] = None
+    usage_act: Optional[UsageAct] = None
+    last_finished_usage_act: Optional[UsageAct] = None
+    last_usage_act: Optional[UsageAct] = None
+    promocode: Optional[Promocode] = None
+    physical_server: Optional[PhysicalServer] = None
+    white_ips: List[WhiteIP] = field(default_factory=list)
+    software_addons: List[SoftwareAddonInstance] = field(default_factory=list)
+    card_background: Optional[str] = None
+    monthly_price_rub: Optional[float] = None
+    total_ram_size: int = 0
+    total_network_disk_size: int = 0
+    total_local_disk_size: int = 0
+    max_available: int = 0
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> CloudServer:
+        return cls(
+            id=data["id"],
+            name=data.get("name", ""),
+            status=data.get("status", 0),
+            price_plan=data.get("price_plan", 0),
+            is_auto_renewal=data.get("is_auto_renewal", False),
+            monthly_price_rub_cents=data.get("monthly_price_rub_cents", 0),
+            hourly_price_rub_cents=data.get("hourly_price_rub_cents", 0),
+            server_full_rent_price_rub_cents=data.get("server_full_rent_price_rub_cents", 0),
+            flavor_oid=_get(data, "flavor_oid"),
+            server_state=data.get("server_state", 0),
+            has_instance=data.get("has_instance", False),
+            credentials=data.get("credentials", ""),
+            ip_to_connect=_get(data, "ip_to_connect"),
+            domain_to_connect=_get(data, "domain_to_connect"),
+            login=data.get("login", ""),
+            gpu=_parse_nested(data, "gpu", GPU),
+            gpu_count=data.get("gpu_count", 0),
+            cpu=_parse_nested(data, "cpu", CPU),
+            cpu_count=data.get("cpu_count", 0),
+            ram=_parse_nested(data, "ram", RAM),
+            ram_count=data.get("ram_count", 0),
+            network_disk=_parse_nested(data, "network_disk", SSD),
+            network_disk_count=data.get("network_disk_count", 0),
+            local_disk=_parse_nested(data, "local_disk", SSD),
+            local_disk_count=data.get("local_disk_count", 0),
+            os=_parse_nested(data, "os", OSImage),
+            usage_act=_parse_nested(data, "usage_act", UsageAct),
+            last_finished_usage_act=_parse_nested(data, "last_finished_usage_act", UsageAct),
+            last_usage_act=_parse_nested(data, "last_usage_act", UsageAct),
+            promocode=_parse_nested(data, "promocode", Promocode),
+            physical_server=_parse_nested(data, "physical_server", PhysicalServer),
+            white_ips=_parse_nested_list(data, "white_ips", WhiteIP),
+            software_addons=_parse_nested_list(data, "software_addons", SoftwareAddonInstance),
+            card_background=_get(data, "card_background"),
+            monthly_price_rub=_get(data, "monthly_price_rub"),
+            total_ram_size=data.get("total_ram_size", 0),
+            total_network_disk_size=data.get("total_network_disk_size", 0),
+            total_local_disk_size=data.get("total_local_disk_size", 0),
+            max_available=data.get("max_available", 0),
+        )
+
+
+@dataclass(frozen=True)
+class ServerStatus:
+    """Result of the pre-start status check endpoint."""
+
+    can_start: bool
+    affordable_runtime_seconds: Optional[int] = None
+    message: Optional[str] = None
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> ServerStatus:
+        return cls(
+            can_start=data.get("can_start", False),
+            affordable_runtime_seconds=_get(data, "affordable_runtime_seconds"),
+            message=_get(data, "message"),
+        )