Add flake8 and improve formatting to pass all checks

Author: devinslick

.flake8

@@ -0,0 +1,3 @@
+[flake8]
+max-line-length = 120
+extend-ignore = E203

fmd_api/__init__.py

@@ -12,4 +12,4 @@
     "DeviceNotFoundError",
     "OperationError",
     "__version__",
-]
+]

fmd_api/_version.py

@@ -1 +1 @@
-__version__ = "2.0.0-dev6"
+__version__ = "2.0.0-dev7"

fmd_api/client.py

@@ -26,9 +26,8 @@
 from cryptography.hazmat.primitives.asymmetric import padding
 from cryptography.hazmat.primitives.ciphers.aead import AESGCM
 
-from .helpers import b64_decode_padded, _pad_base64
-from .exceptions import FmdApiException, AuthenticationError
-from .models import PhotoResult, Location
+from .helpers import _pad_base64
+from .exceptions import FmdApiException
 
 # Constants copied from original module to ensure parity
 CONTEXT_STRING_LOGIN = "context:loginAuthentication"
@@ -183,12 +182,18 @@ async def _make_api_request(self, method: str, endpoint: str, payload: Any,
                 # Handle 401 -> re-authenticate once
                 if resp.status == 401 and retry_auth and self._fmd_id and self._password:
                     log.info("Received 401 Unauthorized, re-authenticating...")
-                    await self.authenticate(self._fmd_id, self._password, self.session_duration)
+                    await self.authenticate(
+                        self._fmd_id, self._password, self.session_duration)
                     payload["IDT"] = self.access_token
-                    return await self._make_api_request(method, endpoint, payload, stream, expect_json, retry_auth=False)
+                    return await self._make_api_request(
+                        method, endpoint, payload, stream, expect_json,
+                        retry_auth=False)
 
                 resp.raise_for_status()
-                log.debug(f"{endpoint} response - status: {resp.status}, content-type: {resp.content_type}, content-length: {resp.content_length}")
+                log.debug(
+                    f"{endpoint} response - status: {resp.status}, "
+                    f"content-type: {resp.content_type}, "
+                    f"content-length: {resp.content_length}")
 
                 if not stream:
                     if expect_json:
@@ -223,13 +228,19 @@ async def _make_api_request(self, method: str, endpoint: str, payload: Any,
     # -------------------------
     # Location / picture access
     # -------------------------
-    async def get_locations(self, num_to_get: int = -1, skip_empty: bool = True, max_attempts: int = 10) -> List[str]:
+    async def get_locations(
+            self, num_to_get: int = -1, skip_empty: bool = True,
+            max_attempts: int = 10) -> List[str]:
         """
         Fetches all or the N most recent location blobs.
         Returns list of base64-encoded blobs (strings), same as original get_all_locations.
         """
-        log.debug(f"Getting locations, num_to_get={num_to_get}, skip_empty={skip_empty}")
-        size_str = await self._make_api_request("PUT", "/api/v1/locationDataSize", {"IDT": self.access_token, "Data": ""})
+        log.debug(
+            f"Getting locations, num_to_get={num_to_get}, "
+            f"skip_empty={skip_empty}")
+        size_str = await self._make_api_request(
+            "PUT", "/api/v1/locationDataSize",
+            {"IDT": self.access_token, "Data": ""})
         size = int(size_str)
         log.debug(f"Server reports {size} locations available")
         if size == 0:
@@ -242,7 +253,9 @@ async def get_locations(self, num_to_get: int = -1, skip_empty: bool = True, max
             indices = range(size)
             for i in indices:
                 log.info(f"  - Downloading location at index {i}...")
-                blob = await self._make_api_request("PUT", "/api/v1/location", {"IDT": self.access_token, "Data": str(i)})
+                blob = await self._make_api_request(
+                    "PUT", "/api/v1/location",
+                    {"IDT": self.access_token, "Data": str(i)})
                 locations.append(blob)
             return locations
         else:
@@ -251,8 +264,11 @@ async def get_locations(self, num_to_get: int = -1, skip_empty: bool = True, max
             start_index = size - 1
 
             if skip_empty:
-                indices = range(start_index, max(-1, start_index - max_attempts), -1)
-                log.info(f"Will search for {num_to_download} non-empty location(s) starting from index {start_index}")
+                indices = range(
+                    start_index, max(-1, start_index - max_attempts), -1)
+                log.info(
+                    f"Will search for {num_to_download} non-empty location(s) "
+                    f"starting from index {start_index}")
             else:
                 end_index = size - num_to_download
                 indices = range(start_index, end_index - 1, -1)
@@ -272,15 +288,19 @@ async def get_locations(self, num_to_get: int = -1, skip_empty: bool = True, max
                 log.warning(f"Empty blob received for location index {i}, repr: {repr(blob[:50] if blob else blob)}")
 
         if not locations and num_to_get != -1:
-            log.warning(f"No valid locations found after checking {min(max_attempts, size)} indices")
+            log.warning(
+                f"No valid locations found after checking "
+                f"{min(max_attempts, size)} indices")
 
         return locations
 
     async def get_pictures(self, num_to_get: int = -1) -> List[Any]:
         """Fetches all or the N most recent picture metadata blobs (raw server response)."""
         try:
             await self._ensure_session()
-            async with self._session.put(f"{self.base_url}/api/v1/pictures", json={"IDT": self.access_token, "Data": ""}) as resp:
+            async with self._session.put(
+                    f"{self.base_url}/api/v1/pictures",
+                    json={"IDT": self.access_token, "Data": ""}) as resp:
                 resp.raise_for_status()
                 json_data = await resp.json()
                 # Extract the Data field if it exists, otherwise use the response as-is
@@ -377,8 +397,6 @@ async def request_location(self, provider: str = "all") -> bool:
         log.info(f"Requesting location update with provider: {provider} (command: {command})")
         return await self.send_command(command)
 
-    
-
     async def set_bluetooth(self, enable: bool) -> bool:
         """Set Bluetooth power explicitly: True = on, False = off."""
         command = "bluetooth on" if enable else "bluetooth off"
@@ -414,4 +432,4 @@ async def take_picture(self, camera: str = "back") -> bool:
             raise ValueError(f"Invalid camera '{camera}'. Must be 'front' or 'back'")
         command = "camera front" if camera == "front" else "camera back"
         log.info(f"Requesting picture from {camera} camera")
-        return await self.send_command(command)
+        return await self.send_command(command)

fmd_api/device.py

@@ -14,12 +14,14 @@
 from .helpers import b64_decode_padded
 from .client import FmdClient
 
+
 def _parse_location_blob(blob_b64: str) -> Location:
     """Helper to decrypt and parse a location blob into Location dataclass."""
     # This function expects the caller to pass in a client to decrypt; kept here
     # for signature clarity in Device methods.
     raise RuntimeError("Internal: _parse_location_blob should not be called directly")
 
+
 class Device:
     def __init__(self, client: FmdClient, fmd_id: str, raw: dict = None):
         self.client = client
@@ -128,16 +130,22 @@ async def download_photo(self, picture_blob_b64: str) -> PhotoResult:
             except Exception:
                 raw_meta = {"note": "binary image or base64 string; no JSON metadata"}
             # Build PhotoResult; mime type not provided by server so default to image/jpeg
-            return PhotoResult(data=image_bytes, mime_type="image/jpeg", timestamp=datetime.now(timezone.utc), raw=raw_meta)
+            return PhotoResult(
+                data=image_bytes,
+                mime_type="image/jpeg",
+                timestamp=datetime.now(
+                    timezone.utc),
+                raw=raw_meta)
         except Exception as e:
             raise OperationError(f"Failed to decode picture blob: {e}") from e
 
     async def lock(self, message: Optional[str] = None, passcode: Optional[str] = None) -> bool:
         # The original API supports "lock" command; it does not carry message/passcode in the current client
-        # Implementation preserves original behavior (sends "lock" command). Extensions can append data if server supports it.
+        # Implementation preserves original behavior (sends "lock" command).
+        # Extensions can append data if server supports it.
         return await self.client.send_command("lock")
 
     async def wipe(self, confirm: bool = False) -> bool:
         if not confirm:
             raise OperationError("wipe() requires confirm=True to proceed (destructive action)")
-        return await self.client.send_command("delete")
+        return await self.client.send_command("delete")

fmd_api/exceptions.py

@@ -1,20 +1,26 @@
 """Typed exceptions for fmd_api v2."""
+
+
 class FmdApiException(Exception):
     """Base exception for FMD API errors."""
     pass
 
+
 class AuthenticationError(FmdApiException):
     """Raised when authentication fails."""
     pass
 
+
 class DeviceNotFoundError(FmdApiException):
     """Raised when a requested device cannot be found."""
     pass
 
+
 class RateLimitError(FmdApiException):
     """Raised when the server indicates rate limiting."""
     pass
 
+
 class OperationError(FmdApiException):
     """Raised for failed operations (commands, downloads, etc)."""
-    pass
+    pass

fmd_api/helpers.py

@@ -1,11 +1,12 @@
 """Small helper utilities."""
 import base64
-from typing import Optional
+
 
 def _pad_base64(s: str) -> str:
     return s + '=' * (-len(s) % 4)
 
+
 def b64_decode_padded(s: str) -> bytes:
     return base64.b64decode(_pad_base64(s))
 
-# Placeholder for pagination helpers, parse helpers, etc.
+# Placeholder for pagination helpers, parse helpers, etc.

fmd_api/models.py

@@ -2,6 +2,7 @@
 from datetime import datetime
 from typing import Optional, Dict, Any
 
+
 @dataclass
 class Location:
     lat: float
@@ -15,9 +16,10 @@ class Location:
     provider: Optional[str] = None
     raw: Optional[Dict[str, Any]] = None
 
+
 @dataclass
 class PhotoResult:
     data: bytes
     mime_type: str
     timestamp: datetime
-    raw: Optional[Dict[str, Any]] = None
+    raw: Optional[Dict[str, Any]] = None

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "fmd_api"
-version = "2.0.0.dev6"
+version = "2.0.0.dev7"
 authors = [{name = "devinslick"}]
 description = "A Python client for the FMD (Find My Device) server API"
 readme = "README.md"

tests/functional/test_auth.py

@@ -3,19 +3,22 @@
 Usage:
   python tests/functional/test_auth.py
 """
+from tests.utils.read_credentials import read_credentials
 import asyncio
 import sys
 from pathlib import Path
 
 # Add repo root to path for package imports
 sys.path.insert(0, str(Path(__file__).parent.parent.parent))
 
-from tests.utils.read_credentials import read_credentials
 
 async def main():
     creds = read_credentials()
-    if not creds.get("BASE_URL") or not creds.get("FMD_ID") or not creds.get("PASSWORD"):
-        print("Missing credentials. Copy tests/utils/credentials.txt.example -> tests/utils/credentials.txt and fill in BASE_URL, FMD_ID, PASSWORD")
+    if not creds.get("BASE_URL") or not creds.get("FMD_ID") or not creds.get(
+            "PASSWORD"):
+        print(
+            "Missing credentials. Copy tests/utils/credentials.txt.example -> "
+            "tests/utils/credentials.txt and fill in BASE_URL, FMD_ID, PASSWORD")
         return
     from fmd_api import FmdClient
     client = await FmdClient.create(creds["BASE_URL"], creds["FMD_ID"], creds["PASSWORD"])