snap-python 0.0.1__tar.gz → 0.0.3__tar.gz

{snap_python-0.0.1 → snap_python-0.0.3}/PKG-INFO

@@ -1,17 +1,21 @@
 Metadata-Version: 2.1
 Name: snap-python
-Version: 0.0.1
-Summary: 
+Version: 0.0.3
+Summary: An api to interact with snapd and snap stores
+Home-page: https://github.com/alexlukens/snap-python
 License: MIT
 Author: Alexander Lukens
 Author-email: alexdlukens@gmail.com
-Requires-Python: >=3.12,<4.0
+Requires-Python: >=3.10,<4.0
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Requires-Dist: httpx (>=0.27.2,<0.28.0)
 Requires-Dist: pydantic (>=2.9.2,<3.0.0)
 Requires-Dist: retry (>=0.9.2,<0.10.0)
+Project-URL: Repository, https://github.com/alexlukens/snap-python
 Description-Content-Type: text/markdown
 
 # snap_python

{snap_python-0.0.1 → snap_python-0.0.3}/pyproject.toml

@@ -1,13 +1,14 @@
 [tool.poetry]
 name = "snap-python"
-version = "0.0.1"
-description = ""
+version = "0.0.3"
+description = "An api to interact with snapd and snap stores"
 authors = ["Alexander Lukens <alexdlukens@gmail.com>"]
 license = "MIT"
 readme = "README.md"
+repository = "https://github.com/alexlukens/snap-python"
 
 [tool.poetry.dependencies]
-python = "^3.12"
+python = "^3.10"
 httpx = "^0.27.2"
 pydantic = "^2.9.2"
 retry = "^0.9.2"
@@ -20,6 +21,8 @@ ruff = "^0.7.4"
 pre-commit = "^4.0.1"
 ipykernel = "^6.29.5"
 pytest-cov = "^6.0.0"
+sphinx = "^8.1.3"
+sphinx-rtd-theme = "^3.0.2"
 
 [build-system]
 requires = ["poetry-core"]

snap_python-0.0.3/src/snap_python/__init__.py

@@ -0,0 +1,7 @@
+import logging
+import os
+
+log_level = os.getenv("SNAP_PYTHON_LOG_LEVEL", "DEBUG").upper()
+numeric_level = getattr(logging, log_level, logging.DEBUG)
+logger = logging.getLogger("snap_python")
+logger.setLevel(numeric_level)

{snap_python-0.0.1 → snap_python-0.0.3}/src/snap_python/client.py

@@ -1,7 +1,11 @@
+import asyncio
 import logging
+from typing import AsyncGenerator
 
 import httpx
+from retry import retry
 
+from snap_python.components.config import ConfigEndpoints
 from snap_python.components.snaps import SnapsEndpoints
 from snap_python.components.store import StoreEndpoints
 from snap_python.schemas.changes import ChangesResponse
@@ -14,6 +18,8 @@ logger.setLevel(logging.DEBUG)
 
 
 class SnapClient(AbstractSnapsClient):
+    """Core class for interacting with the Snap Store and Snapd."""
+
     def __init__(
         self,
         version: str = "v2",
@@ -48,16 +54,42 @@ class SnapClient(AbstractSnapsClient):
             version=self.version,
             headers=self.store_headers,
         )
+        self.config = ConfigEndpoints(self)
 
+    @retry(httpx.HTTPError, tries=3, delay=1, backoff=1)
     async def request(self, method: str, endpoint: str, **kwargs) -> httpx.Response:
+        """
+        Sends an HTTP request to the specified endpoint using the given method and parameters.
+        Args:
+            method (str): The HTTP method to use for the request (e.g., 'GET', 'POST').
+            endpoint (str): The API endpoint to send the request to.
+            **kwargs: Additional keyword arguments to pass to the request.
+        Returns:
+            httpx.Response: The response object from the HTTP request.
+        Raises:
+            httpx.HTTPStatusError: If the response contains an HTTP status code indicating an error.
+        """
+
         response = await self.snapd_client.request(
             method, f"{self._base_url}/{self.version}/{endpoint}", **kwargs
         )
-        logger.debug(f"response: {response.content}")
         response.raise_for_status()
         return response
 
+    @retry(httpx.HTTPError, tries=3, delay=1, backoff=1)
     async def request_raw(self, method: str, endpoint: str, **kwargs) -> httpx.Response:
+        """
+        Sends an HTTP request using the specified method and endpoint.
+        Args:
+            method (str): The HTTP method to use for the request (e.g., 'GET', 'POST').
+            endpoint (str): The endpoint URL to send the request to.
+            **kwargs: Additional keyword arguments to pass to the request.
+        Returns:
+            httpx.Response: The response object resulting from the HTTP request.
+        Raises:
+            httpx.HTTPStatusError: If the response contains an HTTP status code indicating an error.
+        """
+
         response = await self.snapd_client.request(method, endpoint, **kwargs)
 
         response.raise_for_status()
@@ -84,3 +116,23 @@ class SnapClient(AbstractSnapsClient):
             pass
 
         return ChangesResponse.model_validate_json(response.content)
+
+    async def get_changes_by_id_generator(
+        self, change_id: str
+    ) -> AsyncGenerator[ChangesResponse, None]:
+        while True:
+            try:
+                response = await self.request("GET", f"changes/{change_id}")
+            except httpx.HTTPStatusError as e:
+                logger.warning(
+                    f"Bad response status code for get_changes_by_id: {e.response.status_code}"
+                )
+                response = e.response
+                pass
+
+            change_response = ChangesResponse.model_validate_json(response.content)
+            yield change_response
+
+            await asyncio.sleep(
+                0.01
+            )  # Add a delay to avoid spamming the server with requests

snap_python-0.0.3/src/snap_python/components/config.py

@@ -0,0 +1,54 @@
+import asyncio
+import logging
+
+import httpx
+
+from snap_python.schemas.changes import ChangesResponse
+from snap_python.schemas.common import AsyncResponse
+from snap_python.schemas.config import ConfigResponse
+from snap_python.utils import AbstractSnapsClient
+
+logger = logging.getLogger("snap_python.components.snaps")
+
+
+class ConfigEndpoints:
+    def __init__(self, client: AbstractSnapsClient) -> None:
+        self._client = client
+        self.common_endpoint = "snaps"
+
+    async def get_configuration(
+        self, snap: str, keys: list[str] | None = None
+    ) -> ConfigResponse:
+        if keys:
+            response: httpx.Response = await self._client.request(
+                "GET",
+                f"{self.common_endpoint}/{snap}/conf",
+                params={"keys": ",".join(keys)},
+            )
+        else:
+            response: httpx.Response = await self._client.request(
+                "GET", f"{self.common_endpoint}/{snap}/conf"
+            )
+
+        return ConfigResponse.model_validate_json(response.content)
+
+    async def set_configuration(
+        self, snap: str, configuration: dict, wait: bool = True
+    ) -> AsyncResponse | ChangesResponse:
+        # TODO: should check that snap supports configure hook before trying to set configuration
+        response: httpx.Response = await self._client.request(
+            "PUT", f"{self.common_endpoint}/{snap}/conf", json=configuration
+        )
+
+        async_response = AsyncResponse.model_validate_json(response.content)
+        if not wait:
+            return async_response
+        while True:
+            changes = await self._client.get_changes_by_id(async_response.change)
+
+            if changes.ready:
+                break
+
+            await asyncio.sleep(0.1)
+
+        return changes

snap_python-0.0.3/src/snap_python/components/snaps.py

@@ -0,0 +1,175 @@
+import asyncio
+import logging
+from pathlib import Path
+
+import httpx
+
+from snap_python.schemas.changes import ChangesResponse
+from snap_python.schemas.common import AsyncResponse
+from snap_python.schemas.snaps import SingleSnapResponse, SnapListResponse
+from snap_python.utils import AbstractSnapsClient, going_to_reload_daemon
+
+logger = logging.getLogger("snap_python.components.snaps")
+
+
+class SnapsEndpoints:
+    def __init__(self, client: AbstractSnapsClient) -> None:
+        self._client = client
+        self.common_endpoint = "snaps"
+
+    async def list_installed_snaps(self) -> SnapListResponse:
+        response: httpx.Response = await self._client.request(
+            "GET", self.common_endpoint
+        )
+
+        response = SnapListResponse.model_validate_json(response.content)
+        if response.status_code > 299:
+            raise httpx.HTTPStatusError(
+                request=response.request,
+                response=response,
+                message=f"Invalid status code in response: {response.status_code}",
+            )
+        return response
+
+    async def get_snap_info(self, snap: str) -> SingleSnapResponse:
+        try:
+            response: httpx.Response = await self._client.request(
+                "GET", f"{self.common_endpoint}/{snap}"
+            )
+        except httpx.HTTPStatusError as e:
+            logger.debug(
+                "Bad status code from get_snap_info on snap %s: %s",
+                snap,
+                e.response.status_code,
+            )
+            response = e.response
+
+        return SingleSnapResponse.model_validate_json(response.content)
+
+    async def is_snap_installed(self, snap: str) -> bool:
+        snap_info = await self.get_snap_info(snap)
+        if snap_info.status == "OK":
+            return True
+        return False
+
+    async def install_snap(
+        self,
+        snap: str,
+        channel: str = "stable",
+        classic: bool = False,
+        devmode: bool = False,
+        ignore_validation: bool = False,
+        jailmode: bool = False,
+        revision: int = None,
+        filename: str = None,
+        wait: bool = False,
+    ) -> AsyncResponse | ChangesResponse:
+        """Install or sideload a snap
+
+        To sideload a snap, provide the filename parameter with the path to the snap file
+
+
+        Args:
+            snap (str): name of the snap to install
+            channel (str, optional): Channel to install. Defaults to "stable".
+            classic (bool, optional): Install with classic confinement. Defaults to False.
+            devmode (bool, optional): Install with devmode. Defaults to False.
+            ignore_validation (bool, optional): _description_. Defaults to False.
+            jailmode (bool, optional): Install snap with jailmode. Defaults to False.
+            revision (int, optional): install a specific revision of the snap. Defaults to None.
+            filename (str, optional): Path to snap to sideload. Defaults to None.
+            wait (bool, optional): Whether to wait for snap to install. If not waiting, will return async response with change id. Defaults to False.
+
+        Raises:
+            Exception: If error occurs during snap install
+
+        Returns:
+            AsyncResponse | ChangesResponse: If wait is True, will return ChangesResponse. Otherwise, will return AsyncResponse
+        """
+        request_data = {
+            "action": "install",
+            "channel": channel,
+            "classic": classic,
+            "devmode": devmode,
+            "ignore_validation": ignore_validation,
+            "jailmode": jailmode,
+        }
+        if revision:
+            request_data["revision"] = revision
+        if filename:
+            # sideload
+            if not Path(filename).exists():
+                raise FileNotFoundError(f"File {filename} does not exist")
+            request_data["dangerous"] = True
+            raw_response: httpx.Response = await self._client.request(
+                "POST",
+                f"{self.common_endpoint}",
+                data=request_data,
+                files={"snap": open(filename, "rb")},
+            )
+        else:
+            # install from default snap store
+            raw_response: httpx.Response = await self._client.request(
+                "POST", f"{self.common_endpoint}/{snap}", json=request_data
+            )
+        response = AsyncResponse.model_validate_json(raw_response.content)
+        if wait:
+            changes_id = response.change
+            previous_changes = None
+            while True:
+                try:
+                    changes = await self._client.get_changes_by_id(changes_id)
+                    logger.debug(f"Progress: {changes.result.overall_progress}")
+                except httpx.HTTPError as e:
+                    if going_to_reload_daemon(previous_changes):
+                        logger.debug("Waiting for daemon to reload")
+                        await asyncio.sleep(0.1)
+                        continue
+
+                if changes.ready:
+                    break
+                if changes.result.err:
+                    raise Exception(f"Error in snap install: {changes.result.err}")
+                await asyncio.sleep(0.1)
+                previous_changes = changes
+            return changes
+        return response
+
+    async def remove_snap(
+        self,
+        snap: str,
+        purge: bool = False,
+        terminate: bool = False,
+        wait: bool = False,
+    ) -> AsyncResponse | ChangesResponse:
+        request_data = {
+            "action": "remove",
+            "purge": purge,
+            "terminate": terminate,
+        }
+
+        raw_response: httpx.Response = await self._client.request(
+            "POST", f"{self.common_endpoint}/{snap}", json=request_data
+        )
+        response = AsyncResponse.model_validate_json(raw_response.content)
+
+        if wait:
+            changes_id = response.change
+            previous_changes = None
+            while True:
+                try:
+                    changes = await self._client.get_changes_by_id(changes_id)
+                except httpx.HTTPError as e:
+                    if going_to_reload_daemon(previous_changes):
+                        logger.debug("Waiting for daemon to reload")
+                        await asyncio.sleep(0.1)
+                        continue
+                if changes.ready:
+                    break
+                if changes.result.err:
+                    raise Exception(f"Error in snap remove: {changes.result.err}")
+                await asyncio.sleep(0.1)
+                previous_changes = changes
+            return changes
+
+        return response

{snap_python-0.0.1 → snap_python-0.0.3}/src/snap_python/schemas/changes.py

@@ -3,12 +3,23 @@ from pydantic import AliasChoices, AwareDatetime, BaseModel, Field
 from snap_python.schemas.common import BaseErrorResult, BaseResponse
 
 
+class MaintenanceInfo(BaseModel):
+    kind: str
+    message: str
+
+
+class ProgressInfo(BaseModel):
+    label: str
+    done: int
+    total: int
+
+
 class Task(BaseModel):
     id: str
     kind: str
     summary: str
     status: str
-    progress: dict
+    progress: ProgressInfo
     spawn_time: AwareDatetime = Field(
         validation_alias=AliasChoices("spawn-time", "spawn_time"),
         serialization_alias="spawn-time",
@@ -40,12 +51,22 @@ class ChangesResult(BaseModel):
     err: str | None = None
     data: dict | None = None
 
+    @property
+    def overall_progress(self) -> ProgressInfo:
+        if not self.tasks:
+            return ProgressInfo(label="Overall", done=0, total=-1)
+        total = sum(task.progress.total for task in self.tasks)
+        done = sum(task.progress.done for task in self.tasks)
+
+        return ProgressInfo(label="Overall", done=done, total=total)
+
 
 class ChangesResponse(BaseResponse):
     result: ChangesResult | BaseErrorResult
+    maintenance: MaintenanceInfo | None = None
 
     @property
     def ready(self) -> bool:
         if isinstance(self.result, BaseErrorResult):
-            return False
+            return True
         return self.result.ready

snap_python-0.0.3/src/snap_python/schemas/config.py

@@ -0,0 +1,5 @@
+from snap_python.schemas.common import BaseResponse
+
+
+class ConfigResponse(BaseResponse):
+    result: dict

{snap_python-0.0.1 → snap_python-0.0.3}/src/snap_python/schemas/snaps.py

@@ -1,6 +1,7 @@
 from pydantic import AliasChoices, AwareDatetime, BaseModel, ConfigDict, Field
 
 from snap_python.schemas.common import (
+    BaseErrorResult,
     BaseResponse,
     Media,
     SnapApp,
@@ -43,20 +44,25 @@ class Snap(BaseModel):
     )
     name: str
     private: bool
-    publisher: dict[str, str]
+    publisher: dict[str, str] | None = None
     revision: str
     status: str
     summary: str
     title: str | None = None
-    tracking_channel: str = Field(
+    tracking_channel: str | None = Field(
         validation_alias=AliasChoices("tracking-channel", "tracking_channel"),
         serialization_alias="tracking-channel",
+        default=None,
     )
     type: str
     version: str
     website: str | None = None
 
 
+class SingleSnapResponse(BaseResponse):
+    result: Snap | BaseErrorResult
+
+
 class SnapListResponse(BaseResponse):
     result: list[Snap]
 

{snap_python-0.0.1 → snap_python-0.0.3}/src/snap_python/utils.py

@@ -17,3 +17,16 @@ class AbstractSnapsClient(ABC):  # pragma: no cover
     @abstractmethod
     async def get_changes_by_id(self, change_id: str) -> ChangesResponse:
         pass
+
+
+def going_to_reload_daemon(changes: ChangesResponse | None) -> bool:
+    if changes is None or not isinstance(changes, ChangesResponse):
+        return False
+
+    if changes.maintenance and changes.maintenance.kind in [
+        "daemon-reload",
+        "daemon-restart",
+    ]:
+        return True
+
+    return False

snap_python-0.0.1/src/snap_python/components/snaps.py

@@ -1,92 +0,0 @@
-import asyncio
-
-import httpx
-
-from snap_python.schemas.changes import ChangesResponse
-from snap_python.schemas.common import AsyncResponse
-from snap_python.schemas.snaps import SnapListResponse
-from snap_python.utils import AbstractSnapsClient
-
-
-class SnapsEndpoints:
-    def __init__(self, client: AbstractSnapsClient) -> None:
-        self._client = client
-        self.common_endpoint = "snaps"
-
-    async def list_installed_snaps(self) -> SnapListResponse:
-        response: httpx.Response = await self._client.request(
-            "GET", self.common_endpoint
-        )
-
-        response = SnapListResponse.model_validate_json(response.content)
-        if response.status_code > 299:
-            raise httpx.HTTPStatusError(
-                request=response.request,
-                response=response,
-                message=f"Invalid status code in response: {response.status_code}",
-            )
-        return response
-
-    async def install_snap(
-        self,
-        snap: str,
-        channel: str = "stable",
-        classic: bool = False,
-        devmode: bool = False,
-        ignore_validation: bool = False,
-        jailmode: bool = False,
-        revision: int = None,
-        wait: bool = False,
-    ) -> AsyncResponse | ChangesResponse:
-        request_data = {
-            "action": "install",
-            "channel": channel,
-            "classic": classic,
-            "devmode": devmode,
-            "ignore_validation": ignore_validation,
-            "jailmode": jailmode,
-        }
-        if revision:
-            request_data["revision"] = revision
-        raw_response: httpx.Response = await self._client.request(
-            "POST", f"{self.common_endpoint}/{snap}", json=request_data
-        )
-        response = AsyncResponse.model_validate_json(raw_response.content)
-        if wait:
-            changes_id = response.change
-            while True:
-                changes = await self._client.get_changes_by_id(changes_id)
-                if changes.ready:
-                    break
-                if changes.result.err:
-                    raise Exception(f"Error in snap install: {changes.result.err}")
-                await asyncio.sleep(2.0)
-            return changes
-        return response
-
-    async def remove_snap(
-        self, snap: str, purge: bool, terminate: bool, wait: bool = False
-    ) -> AsyncResponse | ChangesResponse:
-        request_data = {
-            "action": "remove",
-            "purge": purge,
-            "terminate": terminate,
-        }
-
-        raw_response: httpx.Response = await self._client.request(
-            "POST", f"{self.common_endpoint}/{snap}", json=request_data
-        )
-        response = AsyncResponse.model_validate_json(raw_response.content)
-
-        if wait:
-            changes_id = response.change
-            while True:
-                changes = await self._client.get_changes_by_id(changes_id)
-                if changes.ready:
-                    break
-                if changes.result.err:
-                    raise Exception(f"Error in snap remove: {changes.result.err}")
-                await asyncio.sleep(2.0)
-            return changes
-
-        return response