aioproxmox 0.0.3a0__tar.gz

aioproxmox-0.0.3a0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 by @CoMPaTech and @erwindouna
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

aioproxmox-0.0.3a0/PKG-INFO

@@ -0,0 +1,158 @@
+Metadata-Version: 2.4
+Name: aioproxmox
+Version: 0.0.3a0
+Summary: Asynchronous Python library for Proxmox products.
+Maintainer: CoMPaTech, erwindouna
+License-Expression: MIT
+Project-URL: Source Code, https://github.com/compatech/aioproxmox
+Project-URL: Bug Reports, https://github.com/compatech/aioproxmox/issues
+Keywords: home,automation,proxmox,pve,proxmoxve,pdm,proxmoxdm,pbs,proxmoxbs
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Home Automation
+Requires-Python: >=3.14
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: aiohttp>=3.14
+Requires-Dist: mashumaro>=3.22
+Dynamic: license-file
+
+# Asynchronous Python library for Proxmox products
+
+An asynchronous, type-safe Python client tailored for extracting raw performance telemetry out of Proxmox VE clusters, nodes, and guests.
+
+## Why another Proxmox library
+
+This library was built out of necessity because existing ecosystem integrations and underlying client libraries have structural limitations. Whether they are synchronous bottlenecks, missing granular unnested endpoint layouts, or lacking strict runtime type enforcement. This library serves as our high-performance bridge today while we wait for any other mainstream library to catch up, open up, or accept modern async paradigms. Once they do, this phase can comfortably conclude.
+
+## Features
+
+* **Strict Asynchronous Execution:** Native `aiohttp` implementation designed never to block the event loop.
+* **Unified REST Client:** Centralized HTTP architecture managing internal auth tickets, cookie construction, and CSRF token propagation seamlessly.
+* **Granular Telemetry Models:** Distinct dataclasses separating cluster maps from deep host (`NodeStatus`), VM (`QemuStatus`), and container (`LXCStatus`) sensor profiles.
+* **Smart Reconciliation:** Automated cache pruning to instantly evict vanished or decommissioned resources from tracking tables using fast set operations.
+
+## Performance
+
+PVE calls can be intense, the `live_test.py` script adds basic timing, especially storage is expensive. Example for a one-node cluster with only local storage:
+
+```text
+Marker / Total time / Diff. time / Progress
+Timing /    0.15 ms /    0.15 ms / Init
+Timing /    0.20 ms /    0.02 ms / Setup
+Timing /   69.37 ms /   69.15 ms / Connect
+Timing /   69.52 ms /    0.07 ms / Cluster Resources
+Timing /   69.67 ms /    0.14 ms / Resource printing done
+Timing /   69.72 ms /    0.04 ms / Time
+Timing /   80.22 ms /   10.49 ms / Qemu List
+Timing /  101.04 ms /   20.75 ms / LXC List
+Timing /  101.16 ms /    0.03 ms / Qemu/LXC listing done
+Timing /  105.41 ms /    4.24 ms / Node Status
+Timing /  110.88 ms /    5.42 ms / VM Status
+Timing /  126.18 ms /   15.24 ms / LXC
+Timing /  126.33 ms /    0.06 ms / Check existing capabilities
+Timing /  126.39 ms /    0.05 ms / Mark time
+Timing /  130.49 ms /    4.08 ms / Permissions fetch
+Timing / 1784.85 ms / 1654.30 ms / Storage
+Timing / 1793.08 ms /    8.13 ms / Backups
+Timing / 1793.17 ms /    0.04 ms / Time
+Timing / 1793.20 ms /    0.00 ms / Guest Agent running VM start
+Timing / 1944.55 ms /  151.33 ms / Guest Agent running VM complete
+Timing / 1944.75 ms /    0.08 ms / Guest Agent stopped VM start
+Timing / 1950.67 ms /    5.90 ms / Guest Agent stopped VM complete
+Timing / 1950.75 ms /    0.03 ms / Time
+```
+
+## Usage
+
+The library provides a modern, fluent interface built on asyncio and aiohttp, designed to mirror the structure of the Proxmox VE API while maintaining strict type safety via dataclasses.
+
+Instead of passing endpoints via string formatting or multi-level item lookups, aioproxmox exposes clean, chainable endpoint paths. All data responses are fully validated dataclass objects rather than raw nested dictionaries.
+
+```python
+import asyncio
+import aiohttp
+import aioproxmox
+
+async def main():
+    async with aiohttp.ClientSession() as session:
+        # Initialize the type-safe client backend
+        pve = aioproxmox.ProxmoxVE(
+            session=session,
+            host="192.168.1.100",
+            user="root@pam",
+            password="your_secure_password",
+            verify_ssl=False
+        )
+
+        cluster = await pve.connect()
+        print(f"Connected to cluster with: {len(cluster.resources)} resources")
+
+        lxc_status = await pve.nodes("pvex").lxc(501).status.current()
+        print(f"Container Memory: {lxc_status.mem} bytes")
+
+        cluster_resources = await pve.cluster.resources()
+        print(f"Total cluster resources tracked: {len(cluster_resources.resources)}")
+
+        node_status = await pve.nodes("pvex").status()
+        print(f"Node CPU usage: {node_status.cpu * 100}%")
+
+        vm_status = await pve.nodes("pvex").qemu(102).status.current()
+        print(f"VM {vm_status.name} Status: {vm_status.status}")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+### Contrast from Proxmoxer
+
+| Feature | `proxmoxer` (Generic String Wrapper) | `aioproxmox` (Type-Safe Telemetry Client) |
+| :--- | :--- | :--- |
+| **I/O Strategy** | Synchronous (blocks the event loop) | Native Asynchronous (`aiohttp`) |
+| **Path Navigation** | Verbatim endpoint strings / properties | Fluid, chainable endpoint paths |
+| **Terminal Calls** | Explicit method tags required (`.get()`) | Direct execution or explicit telemetry targets |
+| **Data Format** | Untyped primitives (`dict` / `list`) | Validated `Mashumaro` Dataclasses |
+
+```python
+"""Example implementation, see scripts/live_test.py for more examples."""
+from proxmoxer import ProxmoxAPI
+
+# Initialize synchronous client
+proxmox = ProxmoxAPI(
+    "192.168.1.100",
+    user="root@pam",
+    password="your_secure_password",
+    verify_ssl=False
+)
+
+# 1. Fetch cluster resources (returns raw lists of dicts)
+resources = proxmox.cluster.resources.get()
+print(f"Total cluster resources tracked: {len(resources)}")
+
+# 2. Fetch specific physical node status
+node_status = proxmox.nodes("pvex").status.get()
+print(f"Node CPU usage: {node_status.get('cpu', 0) * 100}%")
+
+# 3. Fetch QEMU VM status
+vm_status = proxmox.nodes("pvex").qemu(102).status.current.get()
+print(f"VM Status: {vm_status.get('status')}")
+
+# 4. Fetch LXC container status
+lxc_status = proxmox.nodes("pvex").lxc(501).status.current.get()
+print(f"Container Memory: {lxc_status.get('mem')} bytes")
+```
+
+## Development Diagnostics
+
+The repository provides a diagnostic CLI utility to verify authentication mechanics, cookie/ticket attachment, and data serialization against live systems.
+
+### Running the Live Test Script
+
+Execute the script from the root directory by providing your targeted cluster parameters:
+
+```bash
+scripts/live_test.py <host-ip-or-fqdn> "<user@realm>" "<password>"
+```

aioproxmox-0.0.3a0/README.md

@@ -0,0 +1,137 @@
+# Asynchronous Python library for Proxmox products
+
+An asynchronous, type-safe Python client tailored for extracting raw performance telemetry out of Proxmox VE clusters, nodes, and guests.
+
+## Why another Proxmox library
+
+This library was built out of necessity because existing ecosystem integrations and underlying client libraries have structural limitations. Whether they are synchronous bottlenecks, missing granular unnested endpoint layouts, or lacking strict runtime type enforcement. This library serves as our high-performance bridge today while we wait for any other mainstream library to catch up, open up, or accept modern async paradigms. Once they do, this phase can comfortably conclude.
+
+## Features
+
+* **Strict Asynchronous Execution:** Native `aiohttp` implementation designed never to block the event loop.
+* **Unified REST Client:** Centralized HTTP architecture managing internal auth tickets, cookie construction, and CSRF token propagation seamlessly.
+* **Granular Telemetry Models:** Distinct dataclasses separating cluster maps from deep host (`NodeStatus`), VM (`QemuStatus`), and container (`LXCStatus`) sensor profiles.
+* **Smart Reconciliation:** Automated cache pruning to instantly evict vanished or decommissioned resources from tracking tables using fast set operations.
+
+## Performance
+
+PVE calls can be intense, the `live_test.py` script adds basic timing, especially storage is expensive. Example for a one-node cluster with only local storage:
+
+```text
+Marker / Total time / Diff. time / Progress
+Timing /    0.15 ms /    0.15 ms / Init
+Timing /    0.20 ms /    0.02 ms / Setup
+Timing /   69.37 ms /   69.15 ms / Connect
+Timing /   69.52 ms /    0.07 ms / Cluster Resources
+Timing /   69.67 ms /    0.14 ms / Resource printing done
+Timing /   69.72 ms /    0.04 ms / Time
+Timing /   80.22 ms /   10.49 ms / Qemu List
+Timing /  101.04 ms /   20.75 ms / LXC List
+Timing /  101.16 ms /    0.03 ms / Qemu/LXC listing done
+Timing /  105.41 ms /    4.24 ms / Node Status
+Timing /  110.88 ms /    5.42 ms / VM Status
+Timing /  126.18 ms /   15.24 ms / LXC
+Timing /  126.33 ms /    0.06 ms / Check existing capabilities
+Timing /  126.39 ms /    0.05 ms / Mark time
+Timing /  130.49 ms /    4.08 ms / Permissions fetch
+Timing / 1784.85 ms / 1654.30 ms / Storage
+Timing / 1793.08 ms /    8.13 ms / Backups
+Timing / 1793.17 ms /    0.04 ms / Time
+Timing / 1793.20 ms /    0.00 ms / Guest Agent running VM start
+Timing / 1944.55 ms /  151.33 ms / Guest Agent running VM complete
+Timing / 1944.75 ms /    0.08 ms / Guest Agent stopped VM start
+Timing / 1950.67 ms /    5.90 ms / Guest Agent stopped VM complete
+Timing / 1950.75 ms /    0.03 ms / Time
+```
+
+## Usage
+
+The library provides a modern, fluent interface built on asyncio and aiohttp, designed to mirror the structure of the Proxmox VE API while maintaining strict type safety via dataclasses.
+
+Instead of passing endpoints via string formatting or multi-level item lookups, aioproxmox exposes clean, chainable endpoint paths. All data responses are fully validated dataclass objects rather than raw nested dictionaries.
+
+```python
+import asyncio
+import aiohttp
+import aioproxmox
+
+async def main():
+    async with aiohttp.ClientSession() as session:
+        # Initialize the type-safe client backend
+        pve = aioproxmox.ProxmoxVE(
+            session=session,
+            host="192.168.1.100",
+            user="root@pam",
+            password="your_secure_password",
+            verify_ssl=False
+        )
+
+        cluster = await pve.connect()
+        print(f"Connected to cluster with: {len(cluster.resources)} resources")
+
+        lxc_status = await pve.nodes("pvex").lxc(501).status.current()
+        print(f"Container Memory: {lxc_status.mem} bytes")
+
+        cluster_resources = await pve.cluster.resources()
+        print(f"Total cluster resources tracked: {len(cluster_resources.resources)}")
+
+        node_status = await pve.nodes("pvex").status()
+        print(f"Node CPU usage: {node_status.cpu * 100}%")
+
+        vm_status = await pve.nodes("pvex").qemu(102).status.current()
+        print(f"VM {vm_status.name} Status: {vm_status.status}")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+### Contrast from Proxmoxer
+
+| Feature | `proxmoxer` (Generic String Wrapper) | `aioproxmox` (Type-Safe Telemetry Client) |
+| :--- | :--- | :--- |
+| **I/O Strategy** | Synchronous (blocks the event loop) | Native Asynchronous (`aiohttp`) |
+| **Path Navigation** | Verbatim endpoint strings / properties | Fluid, chainable endpoint paths |
+| **Terminal Calls** | Explicit method tags required (`.get()`) | Direct execution or explicit telemetry targets |
+| **Data Format** | Untyped primitives (`dict` / `list`) | Validated `Mashumaro` Dataclasses |
+
+```python
+"""Example implementation, see scripts/live_test.py for more examples."""
+from proxmoxer import ProxmoxAPI
+
+# Initialize synchronous client
+proxmox = ProxmoxAPI(
+    "192.168.1.100",
+    user="root@pam",
+    password="your_secure_password",
+    verify_ssl=False
+)
+
+# 1. Fetch cluster resources (returns raw lists of dicts)
+resources = proxmox.cluster.resources.get()
+print(f"Total cluster resources tracked: {len(resources)}")
+
+# 2. Fetch specific physical node status
+node_status = proxmox.nodes("pvex").status.get()
+print(f"Node CPU usage: {node_status.get('cpu', 0) * 100}%")
+
+# 3. Fetch QEMU VM status
+vm_status = proxmox.nodes("pvex").qemu(102).status.current.get()
+print(f"VM Status: {vm_status.get('status')}")
+
+# 4. Fetch LXC container status
+lxc_status = proxmox.nodes("pvex").lxc(501).status.current.get()
+print(f"Container Memory: {lxc_status.get('mem')} bytes")
+```
+
+## Development Diagnostics
+
+The repository provides a diagnostic CLI utility to verify authentication mechanics, cookie/ticket attachment, and data serialization against live systems.
+
+### Running the Live Test Script
+
+Execute the script from the root directory by providing your targeted cluster parameters:
+
+```bash
+scripts/live_test.py <host-ip-or-fqdn> "<user@realm>" "<password>"
+```

aioproxmox-0.0.3a0/aioproxmox/__init__.py

@@ -0,0 +1,300 @@
+"""Proxmox Home Assistant Integration Service."""
+
+import logging
+import time
+from typing import Any
+
+import aiohttp
+
+from .const import DEFAULT_PVE_PORT
+from .endpoints import AccessEndpoint, ClusterEndpoint, NodeEndpoint
+from .exceptions import ProxmoxAPIError, ProxmoxAuthError
+from .model import PVECapabilities, PVEPermissions
+from .model.pve import ClusterCache, ClusterResourcesCollection
+
+_LOGGER = logging.getLogger(__name__)
+
+SERVICES: dict[str, dict[str, Any]] = {
+    "PVE": {"default_port": DEFAULT_PVE_PORT, "token_separator": "="}
+    # Future PDM, PBS
+}
+
+
+class ProxmoxHTTPAuthBase:
+    """Base class for authentication structures."""
+
+    def __init__(
+        self,
+        session: aiohttp.ClientSession,
+        timeout: float = 5.0,
+        service: str = "PVE",
+        verify_ssl: bool = False,
+    ):
+        """Initialize ticket based authentication."""
+        self.session = session
+        self.timeout = timeout
+        self.service = service
+        self.verify_ssl = verify_ssl
+        self.capabilities: PVECapabilities
+
+    def get_cookies(self) -> dict[str, str]:
+        """Return cookies."""
+        return {}
+
+    def get_headers(self) -> dict[str, str]:
+        """Return headers."""
+        return {}
+
+    async def check_and_refresh(self, method: str) -> None:
+        """Asynchronously refresh credentials if required before a request."""
+
+
+class ProxmoxHTTPAuth(ProxmoxHTTPAuthBase):
+    """Ticket and Cookie based Authentication supporting TFA."""
+
+    renew_age = 3600
+
+    def __init__(
+        self,
+        username: str,
+        password: str,
+        otp: bool | None = None,
+        base_url: str = "",
+        otptype: str = "totp",
+        **kwargs: Any,
+    ) -> None:
+        """Initialize ticket based authentication."""
+        super().__init__(**kwargs)
+        self.base_url = base_url
+        self.username = username
+        self.password = password
+        self.otp = otp
+        self.otptype = otptype
+        self.pve_auth_ticket = ""
+        self.csrf_prevention_token = ""
+        self.birth_time = 0.0
+
+    async def async_init(self) -> Any:
+        """Initial token acquisition loop."""
+        await self._get_new_tokens(
+            password=self.password, otp=self.otp, otptype=self.otptype
+        )
+        return self
+
+    async def _get_new_tokens(
+        self,
+        password: str | None = None,
+        otp: bool | None = None,
+        otptype: str | None = None,
+    ) -> None:
+        """Retrieve new tokens for session."""
+        target_password = password or self.pve_auth_ticket
+        data = {"username": self.username, "password": target_password}
+        timeout = aiohttp.ClientTimeout(total=self.timeout)
+
+        async with self.session.post(
+            f"{self.base_url}/access/ticket",
+            data=data,
+            timeout=timeout,
+            ssl=self.verify_ssl,
+        ) as response:
+            if response.status != 200:
+                raise ProxmoxAuthError(
+                    f"Couldn't authenticate user {self.username} to {self.base_url}/access/ticket: Code {response.status}"
+                )
+            res_json = await response.json()
+            response_data = res_json["data"]
+
+            self.birth_time = time.monotonic()
+            self.pve_auth_ticket = response_data["ticket"]
+            self.csrf_prevention_token = response_data["CSRFPreventionToken"]
+
+            if "cap" in response_data:
+                self.capabilities = PVECapabilities(**response_data["cap"])
+
+            # Secondary step if Two Factor Challenge is detected
+            if response_data.get("NeedTFA") is not None:
+                otpdata = {
+                    "username": self.username,
+                    "tfa-challenge": self.pve_auth_ticket,
+                    "password": f"{otptype}:{otp}",
+                }
+                async with self.session.post(
+                    f"{self.base_url}/access/ticket",
+                    data=otpdata,
+                    timeout=timeout,
+                    ssl=self.verify_ssl,
+                ) as otpresp:
+                    otp_json = await otpresp.json()
+                    otpresp_data = otp_json.get("data")
+                if not otpresp_data:
+                    raise ProxmoxAuthError(
+                        "Couldn't authenticate user: missing Two Factor Authentication (TFA)"
+                    )
+
+                self.birth_time = time.monotonic()
+                self.pve_auth_ticket = otpresp_data["ticket"]
+                self.csrf_prevention_token = otpresp_data["CSRFPreventionToken"]
+
+    def get_cookies(self) -> dict[str, str]:
+        """Return cookies."""
+        return {f"{self.service}AuthCookie": self.pve_auth_ticket}
+
+    def get_headers(self) -> dict[str, str]:
+        """Return headers."""
+        # Return CSRF prevention tokens strictly for mutation traffic
+        return {"CSRFPreventionToken": self.csrf_prevention_token}
+
+    async def check_and_refresh(self, method: str) -> None:
+        """Asynchronously refresh credentials if required before a request."""
+        time_diff = time.monotonic() - self.birth_time
+        if time_diff >= self.renew_age:
+            _LOGGER.debug("Refreshing ticket (age %s)", time_diff)
+            await self._get_new_tokens()
+
+
+class ProxmoxHTTPApiTokenAuth(ProxmoxHTTPAuthBase):
+    """Stateless API Token based Authentication."""
+
+    def __init__(
+        self,
+        username: str,
+        token_name: str,
+        token_value: str,
+        **kwargs: Any,
+    ) -> None:
+        """Initialize token based authentication."""
+        super().__init__(**kwargs)
+        self.username = username
+        self.token_name = token_name
+        self.token_value = token_value
+
+    def get_headers(self) -> dict[str, str]:
+        """Return headers."""
+        sep = SERVICES[self.service]["token_separator"]
+        auth_string = f"{self.service}APIToken={self.username}!{self.token_name}{sep}{self.token_value}"
+        return {"Authorization": auth_string}
+
+
+class ProxmoxVE:
+    """Backend Engine coordinating configuration endpoints and session mapping."""
+
+    def __init__(
+        self,
+        session: aiohttp.ClientSession,
+        host: str,
+        *,
+        user: str | None = None,
+        password: str | None = None,
+        otp: str | None = None,
+        port: int | None = None,
+        verify_ssl: bool = True,
+        timeout: float = 5.0,
+        token_name: str | None = None,
+        token_value: str | None = None,
+        service: str = "PVE",
+    ) -> None:
+        """HTTPS Backend for Proxmox Virtualisation Engine."""
+        if ":" in host and not host.startswith("["):
+            # Clean up base IPv4 parsing strings; ignore legacy bracket rules
+            host, _ = host.split(":", 1)
+
+        if not port:
+            port = int(SERVICES[service]["default_port"])
+
+        self.auth: ProxmoxHTTPAuthBase
+        self.base_url = f"https://{host}:{port}/api2/json"
+        self.verify_ssl = verify_ssl
+        self.timeout = timeout
+        self.permissions = PVEPermissions()
+        self.cluster_resources: ClusterResourcesCollection
+        self.cluster_cache = ClusterCache()
+
+        auth_kwargs: dict[str, Any] = {
+            "session": session,
+            "verify_ssl": verify_ssl,
+            "timeout": timeout,
+            "service": service,
+        }
+
+        if token_name is not None:
+            self.auth = ProxmoxHTTPApiTokenAuth(
+                str(user), token_name, str(token_value), **auth_kwargs
+            )
+        elif password is not None:
+            self.auth = ProxmoxHTTPAuth(
+                str(user), password, bool(otp), base_url=self.base_url, **auth_kwargs
+            )
+        else:
+            raise ProxmoxAuthError("No valid authentication credentials were supplied")
+
+    async def connect(self) -> ClusterResourcesCollection:
+        """Authenticate and gather cluster resources."""
+        if hasattr(self.auth, "async_init"):
+            await self.auth.async_init()
+        return await self.cluster.resources()
+
+    async def request(
+        self,
+        method: str,
+        path: str,
+        json_data: dict[str, Any] | None = None,
+        params: dict[str, Any] | None = None,
+    ) -> dict[Any, Any] | list[Any] | dict[str, Any]:
+        """Unified internal request pipeline managing tickets, CSRF tokens, and cookies."""
+        await self.auth.check_and_refresh(method=method)
+
+        headers: dict[str, str] = {
+            "Accept": "application/json",
+            "Connection": "keep-alive",
+            **self.auth.get_headers(),
+        }
+
+        # Only attach the Cookie header if cookies are present (e.g., Ticket Auth)
+        if cookies := self.auth.get_cookies():
+            headers["Cookie"] = "; ".join([f"{k}={v}" for k, v in cookies.items()])
+
+        request_kwargs: dict[str, Any] = {}
+
+        if method.upper() in ("GET", "DELETE"):
+            query_params = {**(params or {}), **(json_data or {})}
+            if query_params:
+                request_kwargs["params"] = {
+                    k: (int(v) if isinstance(v, bool) else str(v))
+                    for k, v in query_params.items()
+                }
+        elif json_data:
+            request_kwargs["json"] = json_data
+
+        url = f"{self.base_url.rstrip('/')}/{path.lstrip('/')}"
+        timeout = aiohttp.ClientTimeout(total=self.timeout)
+
+        async with self.auth.session.request(
+            method=method,
+            url=url,
+            headers=headers,
+            timeout=timeout,
+            ssl=self.verify_ssl,
+            **request_kwargs,
+        ) as response:
+            if response.status not in (200, 201):
+                text = await response.text()
+                raise ProxmoxAPIError(response.status, text, path)
+
+            payload = await response.json()
+            data = payload.get("data", {})
+            return data if isinstance(data, (dict, list)) else {}
+
+    @property
+    def cluster(self) -> ClusterEndpoint:
+        """Add cluster endpoint."""
+        return ClusterEndpoint(self)
+
+    @property
+    def access(self) -> AccessEndpoint:
+        """Add access endpoint."""
+        return AccessEndpoint(self)
+
+    def nodes(self, node: str) -> NodeEndpoint:
+        """Add nodes endpoint."""
+        return NodeEndpoint(self, node)

aioproxmox-0.0.3a0/aioproxmox/const.py

@@ -0,0 +1,3 @@
+"""Constant definitions."""
+
+DEFAULT_PVE_PORT = 8006