canonicalwebteam.store-api 7.1.0__tar.gz → 7.3.8__tar.gz

{canonicalwebteam_store_api-7.1.0 → canonicalwebteam_store_api-7.3.8}/PKG-INFO

@@ -1,8 +1,9 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: canonicalwebteam.store-api
-Version: 7.1.0
+Version: 7.3.8
 Summary: 
 License: LGPL-3.0
+License-File: LICENSE
 Author: Canonical Web Team
 Author-email: webteam@canonical.com
 Requires-Python: >=3.9,<4.0
@@ -13,6 +14,7 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Requires-Dist: cachetools (>=6.2.0,<7.0.0)
 Requires-Dist: coverage (>=7.0,<8.0)
 Requires-Dist: mypy (>=1.14.1,<2.0.0)

canonicalwebteam_store_api-7.3.8/canonicalwebteam/snap_recommendations.py

@@ -0,0 +1,74 @@
+from os import getenv
+
+from requests import Session
+
+
+RECOMMENDATIONS_API_URL = getenv(
+    "SNAP_RECOMMENDATIONS_API_URL",
+    "https://recommendations.snapcraft.io/api/",
+)
+
+
+class SnapRecommendations:
+    """Helpers for Snap Recommendation Service."""
+
+    def __init__(self, session=Session()):
+        self.session = session
+        self.base_url = RECOMMENDATIONS_API_URL
+
+    def get_endpoint_url(self, endpoint: str) -> str:
+        return f"{self.base_url}{endpoint}"
+
+    def _process_response(self, response):
+        """
+        Process the response from the recommendation service.
+        Raises an HTTPError if the request was not successful.
+        """
+        response.raise_for_status()
+        return response.json()
+
+    def get_categories(self) -> list:
+        """
+        Return the list of recommendation categories.
+
+        Endpoint: [GET] /categories
+        """
+        url = self.get_endpoint_url("categories")
+        response = self.session.get(url)
+        return self._process_response(response)
+
+    def get_category(self, category_id: str) -> list:
+        """
+        Return ranked snaps for a given category.
+
+        Endpoint: [GET] /category/{id}
+        """
+        url = self.get_endpoint_url(f"category/{category_id}")
+        response = self.session.get(url)
+        return self._process_response(response)
+
+    def get_popular(self) -> list:
+        return self.get_category("popular")
+
+    def get_recent(self) -> list:
+        return self.get_category("recent")
+
+    def get_trending(self) -> list:
+        return self.get_category("trending")
+
+    def get_top_rated(self) -> list:
+        return self.get_category("top_rated")
+
+    def get_recently_updated(
+        self, page: int = 1, size: int = 10, timeout: int = 10
+    ) -> dict:
+        """
+        Return recently updated snaps with pagination.
+
+        Endpoint: [GET] /recently-updated?page=<page>&size=<size>
+        Returns: { "page": n, "size": n, "snaps": [ ... ] }
+        """
+        params = {"page": page, "size": size}
+        url = self.get_endpoint_url("recently-updated")
+        response = self.session.get(url, params=params, timeout=timeout)
+        return self._process_response(response)

{canonicalwebteam_store_api-7.1.0 → canonicalwebteam_store_api-7.3.8}/canonicalwebteam/store_api/base.py

@@ -1,3 +1,5 @@
+import logging
+
 from canonicalwebteam.exceptions import (
     PublisherAgreementNotSigned,
     PublisherMacaroonRefreshRequired,
@@ -15,13 +17,71 @@ from canonicalwebteam.exceptions import (
 )
 
 
+logger = logging.getLogger(__name__)
+
+
+def _sanitize_dict(dictionary):
+    result = {}
+    for k, v in dictionary.items():
+        if isinstance(v, str):
+            result[k] = f"<len {len(v)}>"
+        else:
+            result[k] = None
+    return result
+
+
+def _get_request_body(request) -> str:
+    body = request.body
+    if isinstance(body, (bytes, bytearray)):
+        # try to decode utf-8
+        try:
+            body = body.decode()
+        except UnicodeError:
+            # we don't want to guess so we just print the body's length
+            body = f"<len {len(body)}>"
+    elif not isinstance(body, str):
+        # we don't know if the type will be JSON serializable
+        # so we just print the type
+        body = f"{type(body)}"
+    return body
+
+
+def _loggable_request(request):
+    return {
+        "url": request.url,
+        "headers": _sanitize_dict(request.headers),
+        "cookies": _sanitize_dict(request._cookies),
+        "body": _get_request_body(request),
+    }
+
+
+def _loggable_response(response):
+    return {
+        "status": response.status_code,
+        "url": response.url,
+        "headers": _sanitize_dict(response.headers),
+        "cookies": _sanitize_dict(response.cookies),
+        "text": response.text,
+    }
+
+
 class Base:
     def __init__(self, session):
         self.session = session
 
+    def log_detailed_error(self, response):
+        logger.error(
+            "Request failed",
+            extra={
+                "request": _loggable_request(response.request),
+                "response": _loggable_response(response),
+            },
+        )
+
     def process_response(self, response):
         # 5xx responses are not in JSON format
         if response.status_code >= 500:
+            self.log_detailed_error(response)
             if response.status_code == 500:
                 raise StoreApiInternalError("Internal error upstream")
             elif response.status_code == 501:
@@ -42,15 +102,20 @@ class Base:
         try:
             body = response.json()
         except ValueError as decode_error:
+            logger.error(
+                "JSON decoding failed. Response text: %s", response.text
+            )
             api_error_exception = StoreApiResponseDecodeError(
                 "JSON decoding failed: {}".format(decode_error)
             )
             raise api_error_exception
 
         if self._is_macaroon_expired(response.headers):
+            logger.error("Publisher macaroon refresh required")
             raise PublisherMacaroonRefreshRequired
 
         if not response.ok:
+            self.log_detailed_error(response)
             error_list = (
                 body["error_list"]
                 if "error_list" in body

{canonicalwebteam_store_api-7.1.0 → canonicalwebteam_store_api-7.3.8}/canonicalwebteam/store_api/dashboard.py

@@ -10,7 +10,7 @@ from canonicalwebteam.exceptions import (
 
 
 DASHBOARD_API_URL = getenv(
-    "DASHBOARD_API_URL", "https://dashboard.snapcraft.io/"
+    "SNAPSTORE_DASHBOARD_API_URL", "https://dashboard.snapcraft.io/"
 )
 
 

{canonicalwebteam_store_api-7.1.0 → canonicalwebteam_store_api-7.3.8}/canonicalwebteam/store_api/devicegw.py

@@ -60,7 +60,7 @@ class DeviceGW(Base):
         Endpoint:  https://api.snapcraft.io/api/v1/snaps/search
         """
         url = self.get_endpoint_url("search", api_version)
-        headers = self.config[api_version].get("headers")
+        headers = self.config[api_version].get("headers", {}).copy()
 
         if "publisher:" not in search:
             search = search.replace(":", " ")
@@ -245,7 +245,10 @@ class DeviceGW(Base):
         params = {}
         if fields:
             params = {"fields": ",".join(fields)}
-        if channel:
+        # Having an empty channel string tells details endpoint to
+        # not filter by channel. Having None and not including the channel
+        # parameter makes the endpoint default to latest/stable channel
+        if channel is not None:
             params["channel"] = channel
         headers = self.config[api_version].get("headers")
 
@@ -307,7 +310,7 @@ class DeviceGW(Base):
         )["revisions"]
 
     def get_featured_snaps(
-        self, api_version: int = 1, fields: str = "snap_id"
+        self, api_version: int = 1, fields: str = "snap_id", headers: dict = {}
     ) -> dict:
         """
         Documentation: (link to spec)
@@ -315,7 +318,9 @@ class DeviceGW(Base):
         Endpoint: https://api.snapcraft.io/api/v1/snaps/search
         """
         url = self.get_endpoint_url("search")
-        headers = self.config[api_version].get("headers")
+        default_headers = self.config[api_version].get("headers", {})
+
+        merged_headers = {**default_headers, **headers}
 
         params = {
             "scope": "wide",
@@ -326,5 +331,5 @@ class DeviceGW(Base):
         }
 
         return self.process_response(
-            self.session.get(url, params=params, headers=headers)
+            self.session.get(url, params=params, headers=merged_headers)
         )

{canonicalwebteam_store_api-7.1.0 → canonicalwebteam_store_api-7.3.8}/canonicalwebteam/stores_web_redis/utility.py

@@ -3,7 +3,7 @@ from cachetools import TTLCache
 import redis
 import json
 import logging
-from typing import Optional, Any
+from typing import Optional, Any, Union
 
 logger = logging.getLogger(__name__)
 
@@ -12,6 +12,24 @@ port = os.getenv("REDIS_DB_PORT", "6379")
 password = os.getenv("REDIS_DB_PASSWORD", None)
 
 
+class SafeJSONEncoder(json.JSONEncoder):
+    def default(self, obj):
+        if isinstance(obj, (bytes, bytearray)):
+            try:
+                return bytes(obj).decode("utf-8")
+            except UnicodeDecodeError:
+                return f"non-decodable-bytes ({len(obj)} bytes)"
+
+        if isinstance(obj, set):
+            try:
+                return sorted(obj)
+            except Exception:
+                return list(obj)
+        if isinstance(obj, tuple):
+            return list(obj)
+        return super().default(obj)
+
+
 class RedisCache:
     def __init__(self, namespace: str, maxsize: int, ttl: int = 300):
         self.namespace = namespace
@@ -29,20 +47,23 @@ class RedisCache:
             logger.warning("Redis unavailable: %s", e)
             self.redis_available = False
 
-    def _build_key(self, base_key: str, **parts) -> str:
+    def _build_key(
+        self, key: Union[str, tuple[str, Optional[dict[str, Any]]]]
+    ) -> str:
+        base_key, parts = key if isinstance(key, tuple) else (key, {})
         key_parts = ":".join(f"{k}-{v}" for k, v in parts.items() if v)
-        key = (
+        full_key = (
             f"{self.namespace}:{base_key}:{key_parts}"
             if key_parts
             else f"{self.namespace}:{base_key}"
         )
-        return key
+        return full_key
 
     def _serialize(self, value: Any) -> str:
         if isinstance(value, str):
             return value
         try:
-            return json.dumps(value)
+            return json.dumps(value, cls=SafeJSONEncoder)
         except (TypeError, ValueError) as e:
             logger.error("Serialization error: %s", e)
             raise
@@ -60,34 +81,55 @@ class RedisCache:
             logger.error("Deserialization error: %s", e)
             raise
 
-    def get(self, key: str, expected_type: type = str) -> Any:
+    def get(
+        self,
+        key: Union[str, tuple[str, Optional[dict[str, Any]]]],
+        expected_type: type = str,
+    ) -> Any:
+        full_key = self._build_key(key)
         if self.redis_available:
-            full_key = self._build_key(key)
             try:
-                value = self.client.get(full_key)
-                return self._deserialize(value, expected_type)
+                return self._deserialize(
+                    self.client.get(full_key), expected_type
+                )
             except redis.RedisError as e:
                 logger.error("Redis get error: %s", e)
-        value = self.fallback.get(key)
-        return value
+        else:
+            try:
+                return self._deserialize(
+                    self.fallback[full_key], expected_type
+                )
+            except KeyError:
+                return None
+            except Exception as e:
+                logger.error("Fallback cache get error: %s", e)
 
-    def set(self, key: str, value: Any, ttl=300):
+    def set(
+        self,
+        key: Union[str, tuple[str, Optional[dict[str, Any]]]],
+        value: Any,
+        ttl=300,
+    ):
+        full_key = self._build_key(key)
+        serialized = self._serialize(value)
         if self.redis_available:
-            full_key = self._build_key(key)
             try:
-                serialized = self._serialize(value)
                 self.client.setex(full_key, ttl, serialized)
                 return
             except redis.RedisError as e:
                 logger.error("Redis set error: %s", e)
-        self.fallback[key] = value
+        else:
+            try:
+                self.fallback[full_key] = serialized
+            except Exception as e:
+                logger.error("Fallback cache set error: %s", e)
 
-    def delete(self, key: str):
+    def delete(self, key: Union[str, tuple[str, Optional[dict[str, Any]]]]):
+        full_key = self._build_key(key)
         if self.redis_available:
-            full_key = self._build_key(key)
             try:
                 self.client.delete(full_key)
             except redis.RedisError as e:
                 logger.error("Redis delete error: %s", e)
         else:
-            self.fallback.pop(key, None)
+            self.fallback.pop(full_key, None)

{canonicalwebteam_store_api-7.1.0 → canonicalwebteam_store_api-7.3.8}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = 'canonicalwebteam.store-api'
-version = '7.1.0'
+version = '7.3.8'
 description = ''
 authors = ['Canonical Web Team <webteam@canonical.com>']
 license = 'LGPL-3.0'