snap-python 0.1.3__tar.gz → 0.1.5__tar.gz

{snap_python-0.1.3 → snap_python-0.1.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: snap-python
-Version: 0.1.3
+Version: 0.1.5
 Summary: Interact with snapd and snapstore(s) from Python
 License: MIT
 Author: Alexander Lukens

{snap_python-0.1.3 → snap_python-0.1.5}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "snap-python"
-version = "0.1.3"
+version = "0.1.5"
 description = "Interact with snapd and snapstore(s) from Python"
 authors = ["Alexander Lukens <alexdlukens@gmail.com>"]
 license = "MIT"

{snap_python-0.1.3 → snap_python-0.1.5}/src/snap_python/components/snaps.py

@@ -1,12 +1,14 @@
 import asyncio
 import logging
 from pathlib import Path
+from typing import Any
 
 import httpx
 
 from snap_python.schemas.changes import ChangesResponse
-from snap_python.schemas.common import AsyncResponse
+from snap_python.schemas.common import AsyncResponse, BaseErrorResult
 from snap_python.schemas.snaps import (
+    AppsResponse,
     InstalledSnapListResponse,
     SingleInstalledSnapResponse,
 )
@@ -34,14 +36,13 @@ class SnapsEndpoints:
             "GET", self.common_endpoint
         )
 
-        response = InstalledSnapListResponse.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
+        return InstalledSnapListResponse.model_validate_json(response.content)
 
     async def get_snap_info(self, snap: str) -> SingleInstalledSnapResponse:
         """
@@ -331,3 +332,137 @@ class SnapsEndpoints:
                 previous_changes = changes
             return changes
         return response
+
+    async def disable_snap(
+        self,
+        snap: str,
+        wait: bool = False,
+    ) -> AsyncResponse | ChangesResponse:
+        """
+        Disables a snap package.
+
+        :param snap: The name of the snap package to disable.
+        :type snap: str
+        :param wait: Whether to wait for the disable operation to complete. Defaults to False.
+        :type wait: bool, optional
+
+        :returns: The response from the disable operation.
+        :rtype: AsyncResponse | ChangesResponse
+
+        :raises SnapdAPIError: If there is an error during the snap disable operation.
+        """
+        request_data = {
+            "action": "disable",
+        }
+
+        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:
+                    if going_to_reload_daemon(previous_changes):
+                        logger.debug("Waiting for daemon to reload")
+                        await asyncio.sleep(0.1)
+                        continue
+                    raise
+                if changes.ready:
+                    break
+                if isinstance(changes.result, BaseErrorResult):
+                    raise SnapdAPIError(
+                        f"Error in snap disable: {changes.result.message}"
+                    )
+                if changes.result.err:
+                    raise SnapdAPIError(f"Error in snap disable: {changes.result.err}")
+                await asyncio.sleep(0.1)
+                previous_changes = changes
+            return changes
+
+        return response
+
+    async def enable_snap(
+        self,
+        snap: str,
+        wait: bool = False,
+    ) -> AsyncResponse | ChangesResponse:
+        """
+        enables a snap package.
+
+        :param snap: The name of the snap package to enable.
+        :type snap: str
+        :param wait: Whether to wait for the enable operation to complete. Defaults to False.
+        :type wait: bool, optional
+
+        :returns: The response from the enable operation.
+        :rtype: AsyncResponse | ChangesResponse
+
+        :raises SnapdAPIError: If there is an error during the snap enable operation.
+        """
+        request_data = {
+            "action": "enable",
+        }
+
+        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:
+                    if going_to_reload_daemon(previous_changes):
+                        logger.debug("Waiting for daemon to reload")
+                        await asyncio.sleep(0.1)
+                        continue
+                    raise
+                if changes.ready:
+                    break
+                if isinstance(changes.result, BaseErrorResult):
+                    raise SnapdAPIError(
+                        f"Error in snap enable: {changes.result.message}"
+                    )
+                if changes.result.err:
+                    raise SnapdAPIError(f"Error in snap enable: {changes.result.err}")
+                await asyncio.sleep(0.1)
+                previous_changes = changes
+            return changes
+
+        return response
+
+    async def get_snap_apps(
+        self,
+        snap: str,
+        services_only: bool = False,
+    ) -> AppsResponse:
+        """
+        Retrieves the applications associated with a specific snap.
+
+        :param snap: The name of the snap to retrieve applications for.
+        :type snap: str
+        :param services_only: Whether to retrieve only service applications.
+        :type services_only: bool
+
+        :returns: The response containing the list of applications for the specified snap.
+        :rtype: AppsResponse
+        """
+
+        payload: dict[str, Any] = {"names": [snap]}
+        if services_only:
+            payload["select"] = "service"
+
+        response: httpx.Response = await self._client.request(
+            "GET", "apps", params=payload
+        )
+        if response.status_code != 200:
+            raise SnapdAPIError(f"Failed to retrieve apps for snap: {snap}")
+        return AppsResponse.model_validate_json(response.content)

{snap_python-0.1.3 → snap_python-0.1.5}/src/snap_python/components/store.py

@@ -20,6 +20,7 @@ from snap_python.schemas.store.refresh import (
 from snap_python.schemas.store.search import (
     VALID_SEARCH_CATEGORY_FIELDS,
     ArchSearchResponse,
+    PaginatedSnapSearchResponse,
     SearchResponse,
 )
 
@@ -396,3 +397,100 @@ class StoreEndpoints:
         )
         response.raise_for_status()
         return RefreshRevisionResponse.model_validate_json(response.content)
+
+    async def get_many_snap_revision_info(
+        self,
+        snap_name: str,
+        from_revision: int,
+        to_revision: int,
+        arch: str,
+        fields=None,
+    ) -> RefreshRevisionResponse:
+        """Get information about a snap revision.
+
+        :param snap_name: The name of the snap.
+        :type snap_name: str
+        :param revision: The revision of the snap.
+        :type revision: int
+        :param arch: The architecture of the snap to retrieve details about (e.g. amd64, arm64, riscv64, etc).
+        :type arch: str
+
+        :returns: The snap revision information.
+        :rtype: RefreshRevisionResponse
+        """
+
+        # cast revision to int
+        from_revision = int(from_revision)
+        to_revision = int(to_revision)
+        extra_headers = {"Snap-Device-Architecture": arch}
+        snap_info = await self.get_snap_info(snap_name=snap_name)
+
+        # I don't think this matters for the "context" field, so using info from the first available
+        channel_map_item = snap_info.channel_map[0]
+
+        payload = {
+            "context": [
+                {
+                    "tracking-channel": "stable",
+                    "snap-id": snap_info.snap_id,
+                    "revision": channel_map_item.revision,
+                    "instance-key": str(uuid.uuid4()),
+                }
+            ],
+            "actions": [],
+        }
+        for revision in range(from_revision, to_revision + 1):
+            payload["actions"].append(
+                {
+                    "action": "download",
+                    "name": snap_name,
+                    "revision": revision,
+                    "instance-key": str(uuid.uuid4()),
+                }
+            )
+
+        if fields is not None:
+            if not all(field in VALID_SNAP_REFRESH_FIELDS for field in fields):
+                raise ValueError(
+                    f"Invalid fields. Allowed fields: {VALID_SNAP_REFRESH_FIELDS}"
+                )
+        payload["fields"] = fields
+
+        response = await self.snap_refresh(
+            snap_name=snap_name,
+            payload=payload,
+            extra_headers=extra_headers,
+        )
+        response.raise_for_status()
+        return RefreshRevisionResponse.model_validate_json(response.content)
+
+    async def get_snap_search_paginated(
+        self,
+        q: str = "",
+        scope: str = "wide",
+        arch: str = "wide",
+        page: int = 1,
+        limit: int = 100,
+        confinement: str = "strict,classic",
+    ) -> PaginatedSnapSearchResponse:
+        payload = {
+            "scope": scope,
+            "arch": arch,
+            "page": page,
+            "size": limit,
+            "confinement": confinement,
+        }
+        if q:
+            payload["q"] = q
+
+        response = await self.store_client.get(
+            f"{self._raw_base_url}/api/v1/snaps/search",
+            params=payload,
+        )
+
+        response.raise_for_status()
+        response_json = response.json()
+        response_json["page"] = page
+        response_json["limit"] = limit
+
+        return PaginatedSnapSearchResponse.model_validate(response_json)

{snap_python-0.1.3 → snap_python-0.1.5}/src/snap_python/schemas/snaps.py

@@ -32,7 +32,8 @@ class InstalledSnapFields(Revision):
         validation_alias=AliasChoices("ignore-validation", "ignore_validation"),
         serialization_alias="ignore-validation",
     )
-    install_date: AwareDatetime = Field(
+    install_date: Optional[AwareDatetime] = Field(
+        default=None,
         validation_alias=AliasChoices("install-date", "install_date"),
         serialization_alias="install-date",
     )
@@ -98,3 +99,26 @@ class InstalledSnapListResponse(BaseResponse):
 
     def __len__(self):
         return len(self.result)
+
+
+class SnapAppInfo(BaseModel):
+    snap: Optional[str] = None
+    name: str
+    desktop_file: Optional[str] = Field(
+        default=None,
+        validation_alias=AliasChoices("desktop-file", "desktop_file"),
+        serialization_alias="desktop-file",
+    )
+    daemon: Optional[str] = None
+    enabled: Optional[bool] = None
+    active: Optional[bool] = None
+    common_id: Optional[str] = Field(
+        default=None,
+        validation_alias=AliasChoices("common-id", "common_id"),
+        serialization_alias="common-id",
+    )
+    activators: Optional[list[dict]] = None
+
+
+class AppsResponse(BaseResponse):
+    result: list[SnapAppInfo]

{snap_python-0.1.3 → snap_python-0.1.5}/src/snap_python/schemas/store/search.py

@@ -7,6 +7,7 @@ from pydantic import (
     BaseModel,
     ConfigDict,
     Field,
+    computed_field,
 )
 
 from snap_python.schemas.common import Revision
@@ -144,4 +145,35 @@ class ArchSearchResponse(BaseModel):
     results: list[ArchSearchItem] = Field(
         alias=AliasChoices(AliasPath("_embedded", "clickindex:package"), "results")
     )
-    arch: str
+    arch: str = "wide"
+
+
+class PaginatedResponse(BaseModel):
+    total: int
+    page: int = Field(ge=0)
+    limit: int = Field(ge=1, le=100)
+
+    @computed_field
+    @property
+    def next_page(self) -> Optional[int]:
+        if self.page * self.limit + self.limit < self.total:
+            return self.page + 1
+        return None
+
+    @computed_field
+    @property
+    def previous_page(self) -> Optional[int]:
+        if self.page > 0:
+            return self.page - 1
+        return None
+
+    @computed_field
+    @property
+    def has_more(self) -> bool:
+        return self.page * self.limit + self.limit < self.total
+
+
+class PaginatedSnapSearchResponse(PaginatedResponse):
+    results: list[ArchSearchItem] = Field(
+        alias=AliasChoices(AliasPath("_embedded", "clickindex:package"), "results")
+    )