feat: support Storage Box Types

Author: jooola

docs/api.clients.storage_box_types.rst

@@ -0,0 +1,11 @@
+StorageBoxTypesClient
+==================
+
+.. autoclass:: hcloud.storage_box_types.client.StorageBoxTypesClient
+    :members:
+
+.. autoclass:: hcloud.storage_box_types.client.BoundStorageBoxType
+    :members:
+
+.. autoclass:: hcloud.storage_box_types.client.StorageBoxType
+    :members:

hcloud/_client.py

@@ -25,6 +25,7 @@
 from .server_types import ServerTypesClient
 from .servers import ServersClient
 from .ssh_keys import SSHKeysClient
+from .storage_box_types import StorageBoxTypesClient
 from .volumes import VolumesClient
 
 
@@ -250,6 +251,12 @@ def __init__(
         :type: :class:`PlacementGroupsClient <hcloud.placement_groups.client.PlacementGroupsClient>`
         """
 
+        self.storage_box_types = StorageBoxTypesClient(self)
+        """StorageBoxTypesClient Instance
+
+        :type: :class:`StorageBoxTypesClient <hcloud.storage_box_types.client.StorageBoxTypesClient>`
+        """
+
     def _get_user_agent(self) -> str:
         """Get the user agent of the hcloud-python instance with the user application name (if specified)
 

hcloud/storage_box_types/__init__.py

@@ -0,0 +1,15 @@
+from __future__ import annotations
+
+from .client import (
+    BoundStorageBoxType,
+    StorageBoxTypesClient,
+    StorageBoxTypesPageResult,
+)
+from .domain import StorageBoxType
+
+__all__ = [
+    "BoundStorageBoxType",
+    "StorageBoxTypesClient",
+    "StorageBoxTypesPageResult",
+    "StorageBoxType",
+]

hcloud/storage_box_types/client.py

@@ -0,0 +1,105 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, NamedTuple
+
+from ..core import BoundModelBase, ClientEntityBase, Meta
+from .domain import StorageBoxType
+
+if TYPE_CHECKING:
+    from .._client import Client
+
+
+class BoundStorageBoxType(BoundModelBase, StorageBoxType):
+    _client: StorageBoxTypesClient
+
+    model = StorageBoxType
+
+
+class StorageBoxTypesPageResult(NamedTuple):
+    storage_box_types: list[BoundStorageBoxType]
+    meta: Meta
+
+
+class StorageBoxTypesClient(ClientEntityBase):
+    """
+    A client for the Storage Box Types API.
+
+    See https://docs.hetzner.cloud/reference/hetzner#storage-box-types.
+    """
+
+    _client: Client
+
+    def get_by_id(self, id: int) -> BoundStorageBoxType:
+        """
+        Returns a specific Storage Box Type.
+
+        See https://docs.hetzner.cloud/reference/hetzner#storage-box-types-get-a-storage-box-type
+
+        :param id: ID of the Storage Box Type.
+        """
+        response = self._client._request_hetzner(  # pylint: disable=protected-access
+            method="GET",
+            url=f"/storage_box_types/{id}",
+        )
+        return BoundStorageBoxType(self, response["storage_box_type"])
+
+    def get_by_name(self, name: str) -> BoundStorageBoxType | None:
+        """
+        Returns a specific Storage Box Type.
+
+        See https://docs.hetzner.cloud/reference/hetzner#storage-box-types-list-storage-box-types
+
+        :param name: Name of the Storage Box Type.
+        """
+        return self._get_first_by(name=name)
+
+    def get_list(
+        self,
+        name: str | None = None,
+        page: int | None = None,
+        per_page: int | None = None,
+    ) -> StorageBoxTypesPageResult:
+        """
+        Returns a list of Storage Box Types for a specific page.
+
+        See https://docs.hetzner.cloud/reference/hetzner#storage-box-types-list-storage-box-types
+
+        :param name: Name of the Storage Box Type.
+        :param page: Page number to return.
+        :param per_page: Maximum number of entries returned per page.
+        """
+        params: dict[str, Any] = {}
+        if name is not None:
+            params["name"] = name
+        if page is not None:
+            params["page"] = page
+        if per_page is not None:
+            params["per_page"] = per_page
+
+        response = self._client._request_hetzner(  # pylint: disable=protected-access
+            method="GET",
+            url="/storage_box_types",
+            params=params,
+        )
+        return StorageBoxTypesPageResult(
+            storage_box_types=[
+                BoundStorageBoxType(self, o) for o in response["storage_box_types"]
+            ],
+            meta=Meta.parse_meta(response),
+        )
+
+    def get_all(
+        self,
+        name: str | None = None,
+    ) -> list[BoundStorageBoxType]:
+        """
+        Returns all Storage Box Types.
+
+        See https://docs.hetzner.cloud/reference/hetzner#storage-box-types-list-storage-box-types
+
+        :param name: Name of the Storage Box Type.
+        """
+        return self._iter_pages(
+            self.get_list,
+            name=name,
+        )

hcloud/storage_box_types/domain.py

@@ -0,0 +1,49 @@
+from __future__ import annotations
+
+from ..core import BaseDomain, DomainIdentityMixin
+from ..deprecation import DeprecationInfo
+
+
+class StorageBoxType(BaseDomain, DomainIdentityMixin):
+    """
+    Storage Box Type Domain.
+
+    See https://docs.hetzner.cloud/reference/hetzner#storage-box-types.
+    """
+
+    __api_properties__ = (
+        "id",
+        "name",
+        "description",
+        "snapshot_limit",
+        "automatic_snapshot_limit",
+        "subaccounts_limit",
+        "size",
+        "deprecation",
+        "prices",
+    )
+    __slots__ = __api_properties__
+
+    def __init__(
+        self,
+        id: int | None = None,
+        name: str | None = None,
+        description: str | None = None,
+        snapshot_limit: int | None = None,
+        automatic_snapshot_limit: int | None = None,
+        subaccounts_limit: int | None = None,
+        size: int | None = None,
+        prices: list[dict] | None = None,
+        deprecation: dict | None = None,
+    ):
+        self.id = id
+        self.name = name
+        self.description = description
+        self.snapshot_limit = snapshot_limit
+        self.automatic_snapshot_limit = automatic_snapshot_limit
+        self.subaccounts_limit = subaccounts_limit
+        self.size = size
+        self.prices = prices
+        self.deprecation = (
+            DeprecationInfo.from_dict(deprecation) if deprecation is not None else None
+        )

tests/unit/storage_box_types/__init__.py

@@ -0,0 +1,50 @@
+from __future__ import annotations
+
+import pytest
+
+
+@pytest.fixture()
+def storage_box_type1():
+    return {
+        "id": 42,
+        "name": "bx11",
+        "description": "BX11",
+        "snapshot_limit": 10,
+        "automatic_snapshot_limit": 10,
+        "subaccounts_limit": 100,
+        "size": 1099511627776,
+        "prices": [
+            {
+                "location": "fsn1",
+                "price_hourly": {"gross": "0.0051", "net": "0.0051"},
+                "price_monthly": {"gross": "3.2000", "net": "3.2000"},
+                "setup_fee": {"gross": "0.0000", "net": "0.0000"},
+            }
+        ],
+        "deprecation": {
+            "unavailable_after": "2023-09-01T00:00:00+00:00",
+            "announced": "2023-06-01T00:00:00+00:00",
+        },
+    }
+
+
+@pytest.fixture()
+def storage_box_type2():
+    return {
+        "id": 43,
+        "name": "bx21",
+        "description": "BX21",
+        "snapshot_limit": 20,
+        "automatic_snapshot_limit": 20,
+        "subaccounts_limit": 100,
+        "size": 5497558138880,
+        "prices": [
+            {
+                "location": "fsn1",
+                "price_hourly": {"net": "1.0000", "gross": "1.1900"},
+                "price_monthly": {"net": "1.0000", "gross": "1.1900"},
+                "setup_fee": {"net": "1.0000", "gross": "1.1900"},
+            }
+        ],
+        "deprecation": None,
+    }