intelion-cloud 0.2.0__py3-none-any.whl

intelion_cloud/models/users.py

@@ -0,0 +1,73 @@
+"""User model."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Dict, Optional
+
+from ._base import _get
+
+
+@dataclass(frozen=True)
+class User:
+    """Intelion Cloud user account."""
+
+    id: int
+    username: str
+    email: str
+    first_name: str
+    last_name: str
+    current_balance_rub_cents: int
+    held_up_money_rub_cents: int
+    is_phone_verified: bool
+    is_staff: bool
+    legal: Optional[str] = None
+    company_name: str = ""
+    card_number: Optional[str] = None
+    invoice_requested_rub_cents: int = 0
+    balance_top_up_recommend_rub_cents: int = 0
+    available_top_up_rub_cents: int = 0
+    identity_token: Optional[str] = None
+    default_payment_type: Optional[str] = None
+    tg_id: bool = False
+    should_show_referral_banner: bool = False
+    white_label_partner: Optional[str] = None
+    phone_number: Optional[str] = None
+    is_email_verified: bool = False
+    account_manager: Optional[str] = None
+    is_test: bool = False
+    is_edo_connected: bool = False
+    invalid_name: bool = False
+    last_viewed_event: Optional[str] = None
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> User:
+        return cls(
+            id=data["id"],
+            username=data.get("username", ""),
+            email=data.get("email", ""),
+            first_name=data.get("first_name", ""),
+            last_name=data.get("last_name", ""),
+            current_balance_rub_cents=data.get("current_balance_rub_cents", 0),
+            held_up_money_rub_cents=data.get("held_up_money_rub_cents", 0),
+            is_phone_verified=data.get("is_phone_verified", False),
+            is_staff=data.get("is_staff", False),
+            legal=_get(data, "legal"),
+            company_name=data.get("company_name", ""),
+            card_number=_get(data, "card_number"),
+            invoice_requested_rub_cents=data.get("invoice_requested_rub_cents", 0),
+            balance_top_up_recommend_rub_cents=data.get("balance_top_up_recommend_rub_cents", 0),
+            available_top_up_rub_cents=data.get("available_top_up_rub_cents", 0),
+            identity_token=_get(data, "identity_token"),
+            default_payment_type=_get(data, "default_payment_type"),
+            tg_id=data.get("tg_id", False),
+            should_show_referral_banner=data.get("should_show_referral_banner", False),
+            white_label_partner=_get(data, "white_label_partner"),
+            phone_number=_get(data, "phone_number"),
+            is_email_verified=data.get("is_email_verified", False),
+            account_manager=_get(data, "account_manager"),
+            is_test=data.get("is_test", False),
+            is_edo_connected=data.get("is_edo_connected", False),
+            invalid_name=data.get("invalid_name", False),
+            last_viewed_event=_get(data, "last_viewed_event"),
+        )

intelion_cloud/resources/__init__.py

@@ -0,0 +1,17 @@
+"""API resource modules."""
+
+from .cloud_servers import AsyncCloudServers, CloudServers
+from .flavors import AsyncFlavors, Flavors
+from .os_images import AsyncOSImages, OSImages
+from .users import AsyncUsers, Users
+
+__all__ = [
+    "CloudServers",
+    "AsyncCloudServers",
+    "Flavors",
+    "AsyncFlavors",
+    "OSImages",
+    "AsyncOSImages",
+    "Users",
+    "AsyncUsers",
+]

intelion_cloud/resources/_base.py

@@ -0,0 +1,152 @@
+"""Base resource classes providing HTTP methods to resource subclasses."""
+
+from __future__ import annotations
+
+from typing import Any, Callable, Dict, List, Optional, TypeVar
+
+from .._pagination import PaginatedResponse, extract_next_page, parse_paginated
+from .._transport import AsyncTransport, SyncTransport
+
+T = TypeVar("T")
+
+
+class SyncResource:
+    """Base class for synchronous API resources."""
+
+    def __init__(self, transport: SyncTransport) -> None:
+        self._transport = transport
+
+    def _get(self, path: str, *, params: Optional[Dict[str, Any]] = None) -> Any:
+        response = self._transport.request("GET", path, params=params)
+        return response.json()
+
+    def _post(
+        self,
+        path: str,
+        *,
+        json: Optional[Dict[str, Any]] = None,
+        params: Optional[Dict[str, Any]] = None,
+    ) -> Any:
+        response = self._transport.request("POST", path, json=json, params=params)
+        if response.status_code == 204:
+            return None
+        return response.json()
+
+    def _patch(self, path: str, *, json: Dict[str, Any]) -> Any:
+        response = self._transport.request("PATCH", path, json=json)
+        return response.json()
+
+    def _list_all(
+        self,
+        path: str,
+        model_cls: Callable[[Dict[str, Any]], T],
+        *,
+        params: Optional[Dict[str, Any]] = None,
+    ) -> List[T]:
+        """Fetch all pages and return a flat list of model instances."""
+        all_items: List[T] = []
+        current_path = path
+        current_params = params
+
+        while True:
+            data = self._get(current_path, params=current_params)
+            page = parse_paginated(data)
+            all_items.extend(model_cls(item) for item in page["results"])
+
+            next_info = extract_next_page(page["next"])
+            if next_info is None:
+                break
+            current_path, current_params = next_info
+
+        return all_items
+
+    def _list_page(
+        self,
+        path: str,
+        model_cls: Callable[[Dict[str, Any]], T],
+        *,
+        params: Optional[Dict[str, Any]] = None,
+        page: int = 1,
+    ) -> PaginatedResponse[T]:
+        """Fetch a single page of results."""
+        params = dict(params) if params else {}
+        params["page"] = page
+        data = self._get(path, params=params)
+        paginated = parse_paginated(data)
+        return PaginatedResponse(
+            count=paginated["count"],
+            results=[model_cls(item) for item in paginated["results"]],
+            next_url=paginated["next"],
+            previous_url=paginated["previous"],
+        )
+
+
+class AsyncResource:
+    """Base class for asynchronous API resources."""
+
+    def __init__(self, transport: AsyncTransport) -> None:
+        self._transport = transport
+
+    async def _get(self, path: str, *, params: Optional[Dict[str, Any]] = None) -> Any:
+        response = await self._transport.request("GET", path, params=params)
+        return response.json()
+
+    async def _post(
+        self,
+        path: str,
+        *,
+        json: Optional[Dict[str, Any]] = None,
+        params: Optional[Dict[str, Any]] = None,
+    ) -> Any:
+        response = await self._transport.request("POST", path, json=json, params=params)
+        if response.status_code == 204:
+            return None
+        return response.json()
+
+    async def _patch(self, path: str, *, json: Dict[str, Any]) -> Any:
+        response = await self._transport.request("PATCH", path, json=json)
+        return response.json()
+
+    async def _list_all(
+        self,
+        path: str,
+        model_cls: Callable[[Dict[str, Any]], T],
+        *,
+        params: Optional[Dict[str, Any]] = None,
+    ) -> List[T]:
+        """Fetch all pages and return a flat list of model instances."""
+        all_items: List[T] = []
+        current_path = path
+        current_params = params
+
+        while True:
+            data = await self._get(current_path, params=current_params)
+            page = parse_paginated(data)
+            all_items.extend(model_cls(item) for item in page["results"])
+
+            next_info = extract_next_page(page["next"])
+            if next_info is None:
+                break
+            current_path, current_params = next_info
+
+        return all_items
+
+    async def _list_page(
+        self,
+        path: str,
+        model_cls: Callable[[Dict[str, Any]], T],
+        *,
+        params: Optional[Dict[str, Any]] = None,
+        page: int = 1,
+    ) -> PaginatedResponse[T]:
+        """Fetch a single page of results."""
+        params = dict(params) if params else {}
+        params["page"] = page
+        data = await self._get(path, params=params)
+        paginated = parse_paginated(data)
+        return PaginatedResponse(
+            count=paginated["count"],
+            results=[model_cls(item) for item in paginated["results"]],
+            next_url=paginated["next"],
+            previous_url=paginated["previous"],
+        )

intelion_cloud/resources/cloud_servers.py

@@ -0,0 +1,293 @@
+"""Cloud server resource — CRUD, lifecycle actions, clone, migrate."""
+
+from __future__ import annotations
+
+from typing import Any, Dict, List, Optional, Union
+
+from .._pagination import PaginatedResponse
+from ..models.servers import CloudServer, ServerStatus
+from ._base import AsyncResource, SyncResource
+
+_PATH = "cloud-servers/"
+
+
+def _build_action_payload(
+    status: Union[int, str],
+    *,
+    is_auto_renewal: Optional[bool] = None,
+    run_on_affordable_time: bool = False,
+) -> Dict[str, Any]:
+    payload: Dict[str, Any] = {"status": status}
+    if is_auto_renewal is not None:
+        payload["isAutoRenewal"] = is_auto_renewal
+    if run_on_affordable_time:
+        payload["run_on_affordable_time"] = True
+    return payload
+
+
+class CloudServers(SyncResource):
+    """Synchronous cloud server operations."""
+
+    def list(
+        self,
+        *,
+        page: Optional[int] = None,
+    ) -> Union[List[CloudServer], PaginatedResponse[CloudServer]]:
+        """List cloud servers.
+
+        Without ``page``, returns all servers (auto-paginated).
+        With ``page=N``, returns a single :class:`PaginatedResponse`.
+        """
+        if page is not None:
+            return self._list_page(_PATH, CloudServer.from_dict, page=page)
+        return self._list_all(_PATH, CloudServer.from_dict)
+
+    def get(self, server_id: int) -> CloudServer:
+        """Get a single cloud server by ID."""
+        data = self._get(f"{_PATH}{server_id}/")
+        return CloudServer.from_dict(data)
+
+    def create(
+        self,
+        *,
+        name: str,
+        flavor_id: int,
+        ssd_count: int,
+        os_id: int,
+        price_plan: int = 0,
+        promocode_id: Optional[int] = None,
+        is_in_queue: bool = False,
+        addon_ids: Optional[List[int]] = None,
+    ) -> CloudServer:
+        """Create a new cloud server configuration.
+
+        Args:
+            name: Server display name.
+            flavor_id: FlavorConfig primary key. CPU/RAM/GPU are fixed by the flavor.
+            ssd_count: Network disk size in GB (min 30). Maps to ``network_disk_count`` server-side.
+            os_id: Operating system image ID (must be compatible with the flavor).
+            price_plan: Billing plan (use :class:`~intelion_cloud.constants.PricePlan`).
+            promocode_id: Promotional code ID to apply.
+            is_in_queue: If True, queue the order when hardware is unavailable.
+            addon_ids: Software addon IDs to install at first boot.
+        """
+        payload: Dict[str, Any] = {
+            "name": name,
+            "flavor_id": flavor_id,
+            "ssd_count": ssd_count,
+            "os_id": os_id,
+            "price_plan": price_plan,
+        }
+        if promocode_id is not None:
+            payload["promocode_id"] = promocode_id
+        if is_in_queue:
+            payload["is_in_queue"] = True
+        if addon_ids:
+            payload["addon_ids"] = list(addon_ids)
+
+        data = self._post(_PATH, json=payload)
+        return CloudServer.from_dict(data)
+
+    def update(
+        self,
+        server_id: int,
+        *,
+        name: Optional[str] = None,
+        is_auto_renewal: Optional[bool] = None,
+    ) -> CloudServer:
+        """Update server properties (name, auto-renewal)."""
+        payload: Dict[str, Any] = {}
+        if name is not None:
+            payload["name"] = name
+        if is_auto_renewal is not None:
+            payload["is_auto_renewal"] = is_auto_renewal
+        data = self._patch(f"{_PATH}{server_id}/", json=payload)
+        return CloudServer.from_dict(data)
+
+    # --- Lifecycle actions ---
+
+    def start(
+        self,
+        server_id: int,
+        *,
+        is_auto_renewal: Optional[bool] = None,
+        run_on_affordable_time: bool = False,
+    ) -> CloudServer:
+        """Start a stopped server."""
+        payload = _build_action_payload(
+            2,  # ServerStatus.ACTIVE
+            is_auto_renewal=is_auto_renewal,
+            run_on_affordable_time=run_on_affordable_time,
+        )
+        data = self._post(f"{_PATH}{server_id}/actions/", json=payload)
+        return CloudServer.from_dict(data)
+
+    def stop(self, server_id: int) -> CloudServer:
+        """Stop (shelve) a running server."""
+        data = self._post(f"{_PATH}{server_id}/actions/", json={"status": -1})
+        return CloudServer.from_dict(data)
+
+    def reboot(self, server_id: int) -> CloudServer:
+        """Reboot a running server."""
+        data = self._post(f"{_PATH}{server_id}/actions/", json={"status": "REBOOT"})
+        return CloudServer.from_dict(data)
+
+    def delete(self, server_id: int) -> CloudServer:
+        """Delete a server (irreversible)."""
+        data = self._post(f"{_PATH}{server_id}/actions/", json={"status": -3})
+        return CloudServer.from_dict(data)
+
+    # --- Info endpoints ---
+
+    def get_status(self, server_id: int) -> ServerStatus:
+        """Check if a server can be started and get affordable runtime."""
+        data = self._get(f"{_PATH}{server_id}/status/")
+        return ServerStatus.from_dict(data)
+
+    def get_password(self, server_id: int) -> str:
+        """Get the server password (available after first boot)."""
+        data = self._get(f"{_PATH}{server_id}/password/")
+        if isinstance(data, dict):
+            return data.get("password", "")
+        return str(data)
+
+    # --- Advanced operations ---
+
+    def clone(self, server_id: int) -> CloudServer:
+        """Clone a server (creates an identical copy)."""
+        data = self._post(f"{_PATH}{server_id}/clone/")
+        return CloudServer.from_dict(data)
+
+    def migrate(
+        self,
+        server_id: int,
+        *,
+        flavor_id: int,
+        price_plan: int,
+    ) -> CloudServer:
+        """Migrate a server to a different FlavorConfig and/or price plan.
+
+        The server must be stopped before migration. CPU/RAM/GPU are fixed by the flavor.
+        """
+        payload: Dict[str, Any] = {
+            "flavor_id": flavor_id,
+            "price_plan": price_plan,
+        }
+        data = self._post(f"{_PATH}{server_id}/migrate/", json=payload)
+        return CloudServer.from_dict(data)
+
+
+class AsyncCloudServers(AsyncResource):
+    """Asynchronous cloud server operations."""
+
+    async def list(
+        self,
+        *,
+        page: Optional[int] = None,
+    ) -> Union[List[CloudServer], PaginatedResponse[CloudServer]]:
+        if page is not None:
+            return await self._list_page(_PATH, CloudServer.from_dict, page=page)
+        return await self._list_all(_PATH, CloudServer.from_dict)
+
+    async def get(self, server_id: int) -> CloudServer:
+        data = await self._get(f"{_PATH}{server_id}/")
+        return CloudServer.from_dict(data)
+
+    async def create(
+        self,
+        *,
+        name: str,
+        flavor_id: int,
+        ssd_count: int,
+        os_id: int,
+        price_plan: int = 0,
+        promocode_id: Optional[int] = None,
+        is_in_queue: bool = False,
+        addon_ids: Optional[List[int]] = None,
+    ) -> CloudServer:
+        payload: Dict[str, Any] = {
+            "name": name,
+            "flavor_id": flavor_id,
+            "ssd_count": ssd_count,
+            "os_id": os_id,
+            "price_plan": price_plan,
+        }
+        if promocode_id is not None:
+            payload["promocode_id"] = promocode_id
+        if is_in_queue:
+            payload["is_in_queue"] = True
+        if addon_ids:
+            payload["addon_ids"] = list(addon_ids)
+
+        data = await self._post(_PATH, json=payload)
+        return CloudServer.from_dict(data)
+
+    async def update(
+        self,
+        server_id: int,
+        *,
+        name: Optional[str] = None,
+        is_auto_renewal: Optional[bool] = None,
+    ) -> CloudServer:
+        payload: Dict[str, Any] = {}
+        if name is not None:
+            payload["name"] = name
+        if is_auto_renewal is not None:
+            payload["is_auto_renewal"] = is_auto_renewal
+        data = await self._patch(f"{_PATH}{server_id}/", json=payload)
+        return CloudServer.from_dict(data)
+
+    async def start(
+        self,
+        server_id: int,
+        *,
+        is_auto_renewal: Optional[bool] = None,
+        run_on_affordable_time: bool = False,
+    ) -> CloudServer:
+        payload = _build_action_payload(
+            2,
+            is_auto_renewal=is_auto_renewal,
+            run_on_affordable_time=run_on_affordable_time,
+        )
+        data = await self._post(f"{_PATH}{server_id}/actions/", json=payload)
+        return CloudServer.from_dict(data)
+
+    async def stop(self, server_id: int) -> CloudServer:
+        data = await self._post(f"{_PATH}{server_id}/actions/", json={"status": -1})
+        return CloudServer.from_dict(data)
+
+    async def reboot(self, server_id: int) -> CloudServer:
+        data = await self._post(f"{_PATH}{server_id}/actions/", json={"status": "REBOOT"})
+        return CloudServer.from_dict(data)
+
+    async def delete(self, server_id: int) -> CloudServer:
+        data = await self._post(f"{_PATH}{server_id}/actions/", json={"status": -3})
+        return CloudServer.from_dict(data)
+
+    async def get_status(self, server_id: int) -> ServerStatus:
+        data = await self._get(f"{_PATH}{server_id}/status/")
+        return ServerStatus.from_dict(data)
+
+    async def get_password(self, server_id: int) -> str:
+        data = await self._get(f"{_PATH}{server_id}/password/")
+        if isinstance(data, dict):
+            return data.get("password", "")
+        return str(data)
+
+    async def clone(self, server_id: int) -> CloudServer:
+        data = await self._post(f"{_PATH}{server_id}/clone/")
+        return CloudServer.from_dict(data)
+
+    async def migrate(
+        self,
+        server_id: int,
+        *,
+        flavor_id: int,
+        price_plan: int,
+    ) -> CloudServer:
+        payload: Dict[str, Any] = {
+            "flavor_id": flavor_id,
+            "price_plan": price_plan,
+        }
+        data = await self._post(f"{_PATH}{server_id}/migrate/", json=payload)
+        return CloudServer.from_dict(data)

intelion_cloud/resources/flavors.py

@@ -0,0 +1,42 @@
+"""Flavor resource — list available server configurations."""
+
+from __future__ import annotations
+
+from typing import List, Optional, Union
+
+from .._pagination import PaginatedResponse
+from ..models.flavors import Flavor
+from ._base import AsyncResource, SyncResource
+
+_PATH = "flavors/"
+
+
+class Flavors(SyncResource):
+    """Synchronous flavor operations."""
+
+    def list(
+        self,
+        *,
+        page: Optional[int] = None,
+    ) -> Union[List[Flavor], PaginatedResponse[Flavor]]:
+        """List available flavors.
+
+        Without ``page``, returns all flavors (auto-paginated).
+        With ``page=N``, returns a single :class:`PaginatedResponse`.
+        """
+        if page is not None:
+            return self._list_page(_PATH, Flavor.from_dict, page=page)
+        return self._list_all(_PATH, Flavor.from_dict)
+
+
+class AsyncFlavors(AsyncResource):
+    """Asynchronous flavor operations."""
+
+    async def list(
+        self,
+        *,
+        page: Optional[int] = None,
+    ) -> Union[List[Flavor], PaginatedResponse[Flavor]]:
+        if page is not None:
+            return await self._list_page(_PATH, Flavor.from_dict, page=page)
+        return await self._list_all(_PATH, Flavor.from_dict)

intelion_cloud/resources/os_images.py

@@ -0,0 +1,66 @@
+"""OS image resource — list available operating system images."""
+
+from __future__ import annotations
+
+from typing import Any, Dict, List, Optional, Union
+
+from .._pagination import PaginatedResponse
+from ..models.components import OSImage
+from ._base import AsyncResource, SyncResource
+
+_PATH = "os-images/"
+
+
+class OSImages(SyncResource):
+    """Synchronous OS image operations."""
+
+    def list(
+        self,
+        *,
+        flavor_id: Optional[int] = None,
+        gpu_id: Optional[int] = None,
+        page: Optional[int] = None,
+    ) -> Union[List[OSImage], PaginatedResponse[OSImage]]:
+        """List available OS images.
+
+        Args:
+            flavor_id: Filter images compatible with a specific FlavorConfig
+                (preferred — the canonical compatibility dimension).
+            gpu_id: Filter images compatible with any flavor that uses this GPU.
+            page: If given, return a single page instead of all results.
+
+        Without any filter, only universal images (compatible with every flavor)
+        are returned.
+        """
+        params: Dict[str, Any] = {}
+        if flavor_id is not None:
+            params["flavor_id"] = flavor_id
+        elif gpu_id is not None:
+            params["gpu_id"] = gpu_id
+
+        if page is not None:
+            return self._list_page(_PATH, OSImage.from_dict, params=params or None, page=page)
+        return self._list_all(_PATH, OSImage.from_dict, params=params or None)
+
+
+class AsyncOSImages(AsyncResource):
+    """Asynchronous OS image operations."""
+
+    async def list(
+        self,
+        *,
+        flavor_id: Optional[int] = None,
+        gpu_id: Optional[int] = None,
+        page: Optional[int] = None,
+    ) -> Union[List[OSImage], PaginatedResponse[OSImage]]:
+        params: Dict[str, Any] = {}
+        if flavor_id is not None:
+            params["flavor_id"] = flavor_id
+        elif gpu_id is not None:
+            params["gpu_id"] = gpu_id
+
+        if page is not None:
+            return await self._list_page(
+                _PATH, OSImage.from_dict, params=params or None, page=page
+            )
+        return await self._list_all(_PATH, OSImage.from_dict, params=params or None)