Merge pull request #3 from srichs/codex/fix-black-ci-issues

Apply Black formatting fixes to resolve CI failures

Author: srichs

docs/conf.py

@@ -1,4 +1,5 @@
 """Sphinx configuration for the python-spot documentation."""
+
 from __future__ import annotations
 
 import os
@@ -34,5 +35,5 @@
 exclude_patterns: list[str] = ["_build"]
 
 html_static_path = ["_static"]
-#html_theme = "alabaster"
+# html_theme = "alabaster"
 html_theme = "furo"

spot_api/__init__.py

@@ -1,4 +1,5 @@
 """Public exports for the Spot API package."""
+
 from .client import SpotApi, SpotRequestResult, SpotRequestStatus
 from .enums import (
     SpotBatteryState,

spot_api/client.py

@@ -1,4 +1,5 @@
 """Async client implementation for interacting with the Spot API."""
+
 from __future__ import annotations
 
 import asyncio
@@ -73,7 +74,9 @@ def __bool__(self) -> bool:  # pragma: no cover - convenience wrapper
 class SpotApi(object):
     """High-level interface for accessing Spot feeds and messages."""
 
-    SPOT_API_ENDPOINT: str = "https://api.findmespot.com/spot-main-web/consumer/rest-api/2.0/public/feed/"
+    SPOT_API_ENDPOINT: str = (
+        "https://api.findmespot.com/spot-main-web/consumer/rest-api/2.0/public/feed/"
+    )
     # Spot asks to wait at least 2.5 minutes between requests of the same feed
     SPOT_API_WAIT_TIME: int = 150
     # Spot asks to wait at least 2 seconds between requests for different feeds
@@ -148,9 +151,7 @@ def get_last_response(self, feed_id: Optional[str] = None) -> Optional[dict]:
             return None
         return self._last_response.get(target_feed_id)
 
-    def _normalize_feed_list(
-        self, feed_list: Iterable[FeedEntry]
-    ) -> list[FeedEntry]:
+    def _normalize_feed_list(self, feed_list: Iterable[FeedEntry]) -> list[FeedEntry]:
         """Validate and normalize the configured feeds.
 
         Converting the IDs and passwords to strings up front ensures the rest of the
@@ -467,7 +468,10 @@ async def request_all_pages(
 
             if result.status is SpotRequestStatus.THROTTLED:
                 throttle_count += 1
-                if max_throttled_retries is not None and throttle_count > max_throttled_retries:
+                if (
+                    max_throttled_retries is not None
+                    and throttle_count > max_throttled_retries
+                ):
                     logger.warning(
                         "Aborting pagination for feed %s after %s throttled responses",
                         feed.id,
@@ -518,7 +522,9 @@ async def _request(
         allowed, wait_seconds = self._can_dispatch_request(feed)
         if not allowed:
             logger.debug(
-                "Throttling request for feed %s; %.2f seconds remaining", feed.id, wait_seconds
+                "Throttling request for feed %s; %.2f seconds remaining",
+                feed.id,
+                wait_seconds,
             )
             return SpotRequestResult(
                 SpotRequestStatus.THROTTLED,
@@ -582,7 +588,9 @@ async def _perform_http_request(
     ) -> httpx.Response | SpotRequestResult:
         try:
             client = self._ensure_client()
-            response = await client.get(url, params=payload, headers=headers_for_request)
+            response = await client.get(
+                url, params=payload, headers=headers_for_request
+            )
             response.raise_for_status()
         except httpx.HTTPError as exc:
             logger.exception("HTTP error while contacting Spot API")
@@ -770,7 +778,9 @@ def _retry_after_seconds(self, response: Optional[httpx.Response]) -> float:
             return default_wait
 
         try:
-            retry_after = response.headers.get("Retry-After") if response.headers else None
+            retry_after = (
+                response.headers.get("Retry-After") if response.headers else None
+            )
         except Exception:  # pragma: no cover - defensive
             retry_after = None
 
@@ -839,7 +849,9 @@ def _build_request(
 
         if start_dt and end_dt:
             if end_dt < start_dt:
-                raise ValueError("End datetime must be greater than or equal to start datetime")
+                raise ValueError(
+                    "End datetime must be greater than or equal to start datetime"
+                )
 
             payload["startDate"] = self._format_request_datetime(start_dt)
             payload["endDate"] = self._format_request_datetime(end_dt)
@@ -906,7 +918,7 @@ def _calculate_throttle_wait(
 
     @staticmethod
     def _normalize_headers(
-        headers: Optional[Mapping[str, str]]
+        headers: Optional[Mapping[str, str]],
     ) -> Optional[Dict[str, str]]:
         if headers is None:
             return None
@@ -919,7 +931,7 @@ def _normalize_headers(
 
     @staticmethod
     def _normalize_query_params(
-        params: Optional[Mapping[str, str]]
+        params: Optional[Mapping[str, str]],
     ) -> Optional[Dict[str, str]]:
         if params is None:
             return None
@@ -1021,7 +1033,9 @@ async def _reset_client_after_sync_run(self) -> None:
         try:
             await client.aclose()
         except Exception:  # pragma: no cover - defensive cleanup
-            logger.warning("Failed to close AsyncClient after synchronous run", exc_info=True)
+            logger.warning(
+                "Failed to close AsyncClient after synchronous run", exc_info=True
+            )
 
     @staticmethod
     def _now() -> datetime.datetime:

spot_api/enums.py

@@ -1,4 +1,5 @@
 """Enumeration definitions for the Spot API client."""
+
 from __future__ import annotations
 
 import logging

spot_api/models.py

@@ -1,4 +1,5 @@
 """Data models and parsing helpers for Spot API responses."""
+
 from __future__ import annotations
 
 import datetime
@@ -107,10 +108,18 @@ def from_json(cls, message: Mapping[str, Any]) -> "SpotMessage":
         if not isinstance(message, Mapping):
             raise TypeError("message must be a mapping")
 
-        required_fields = ["@clientUnixTime", "id", "messengerId", "messengerName", "unixTime"]
+        required_fields = [
+            "@clientUnixTime",
+            "id",
+            "messengerId",
+            "messengerName",
+            "unixTime",
+        ]
         missing_fields = [field for field in required_fields if field not in message]
         if missing_fields:
-            logger.warning("Missing expected message fields: %s", ", ".join(missing_fields))
+            logger.warning(
+                "Missing expected message fields: %s", ", ".join(missing_fields)
+            )
 
         message_type = None
         if "messageType" in message:
@@ -131,7 +140,9 @@ def from_json(cls, message: Mapping[str, Any]) -> "SpotMessage":
 
         date_time = _parse_datetime(message.get("dateTime"))
         raw_battery_state = message.get("batteryState")
-        battery_state = SpotBatteryState.from_str("" if raw_battery_state is None else str(raw_battery_state))
+        battery_state = SpotBatteryState.from_str(
+            "" if raw_battery_state is None else str(raw_battery_state)
+        )
 
         hidden = _coerce_int(message.get("hidden", 0))
         altitude = _coerce_int(message.get("altitude", 0))
@@ -167,9 +178,7 @@ def get_short_datetime(self) -> str:
             else:
                 return datetime.datetime.fromtimestamp(
                     unix_time_int, tz=datetime.timezone.utc
-                ).strftime(
-                    "%Y-%m-%d %H:%M:%S"
-                )
+                ).strftime("%Y-%m-%d %H:%M:%S")
 
         return ""
 
@@ -193,12 +202,12 @@ def _check_longitude(longitude: Optional[float]) -> float:
     def __str__(self) -> str:
         msg_str = "-------------------------------\n"
         msg_str += f"Spot Message ({self.id})\n"
-        msg_str += (
-            f"'{self.messenger_name}' {self.messenger_id} ({self.model_id} - {self.message_type})\n"
-        )
+        msg_str += f"'{self.messenger_name}' {self.messenger_id} ({self.model_id} - {self.message_type})\n"
         msg_str += f"Battery: {self.battery_state}\n"
         timestamp = (
-            self.date_time.isoformat(" ") if self.date_time is not None else self.get_short_datetime()
+            self.date_time.isoformat(" ")
+            if self.date_time is not None
+            else self.get_short_datetime()
         )
         msg_str += f"{timestamp} ({self.unix_time})\n"
         msg_str += self.get_location()
@@ -228,17 +237,22 @@ def from_json(self, response: Mapping[str, Any], *, merge: bool = False) -> None
             raise TypeError("response must be a mapping")
 
         if "response" not in response:
-            logger.warning("No response payload present in Spot feed data: %s", response)
+            logger.warning(
+                "No response payload present in Spot feed data: %s", response
+            )
             return
 
         if "feedMessageResponse" not in response["response"]:
-            logger.warning("No feedMessageResponse present in Spot feed response: %s", response)
+            logger.warning(
+                "No feedMessageResponse present in Spot feed response: %s", response
+            )
             return
 
         feed_message_response = response["response"]["feedMessageResponse"]
         if not isinstance(feed_message_response, Mapping):
             logger.warning(
-                "feedMessageResponse payload was not a mapping in feed %s response", self.id
+                "feedMessageResponse payload was not a mapping in feed %s response",
+                self.id,
             )
             return
         feed_json = feed_message_response.get("feed", {})
@@ -249,9 +263,7 @@ def from_json(self, response: Mapping[str, Any], *, merge: bool = False) -> None
         self.description = feed_json.get("description", "")
         raw_status = feed_json.get("status")
         self.status = (
-            SpotFeedStatus.from_str(str(raw_status))
-            if raw_status is not None
-            else None
+            SpotFeedStatus.from_str(str(raw_status)) if raw_status is not None else None
         )
         self.usage = _coerce_int(feed_json.get("usage", 0))
         self.days_range = _coerce_int(feed_json.get("daysRange", 0))
@@ -260,9 +272,7 @@ def from_json(self, response: Mapping[str, Any], *, merge: bool = False) -> None
         )
         raw_type = feed_json.get("type")
         self.type = (
-            SpotFeedType.from_str(str(raw_type))
-            if raw_type is not None
-            else None
+            SpotFeedType.from_str(str(raw_type)) if raw_type is not None else None
         )
         count = _coerce_int(feed_message_response.get("count", 0))
 
@@ -291,7 +301,9 @@ def from_json(self, response: Mapping[str, Any], *, merge: bool = False) -> None
         iterable: Iterable
         if isinstance(message_payload, Mapping):
             iterable = message_payload.values()
-        elif isinstance(message_payload, Sequence) and not isinstance(message_payload, (str, bytes)):
+        elif isinstance(message_payload, Sequence) and not isinstance(
+            message_payload, (str, bytes)
+        ):
             iterable = message_payload
         else:
             logger.warning(
@@ -311,7 +323,9 @@ def from_json(self, response: Mapping[str, Any], *, merge: bool = False) -> None
                 continue
             msg_id = message_json.get("messengerId")
             if not msg_id:
-                logger.warning("Encountered message without messengerId in feed %s", self.id)
+                logger.warning(
+                    "Encountered message without messengerId in feed %s", self.id
+                )
                 continue
 
             message = SpotMessage.from_json(message_json)
@@ -335,7 +349,8 @@ def iter_messages(self, *, newest_first: bool = True) -> Iterable[SpotMessage]:
             all_messages.extend(device_messages)
 
         all_messages.sort(
-            key=lambda message: message.date_time or datetime.datetime.min.replace(tzinfo=datetime.timezone.utc),
+            key=lambda message: message.date_time
+            or datetime.datetime.min.replace(tzinfo=datetime.timezone.utc),
             reverse=newest_first,
         )