syncfm-core 0.2.0__tar.gz → 0.2.2__tar.gz

{syncfm_core-0.2.0 → syncfm_core-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: syncfm-core
-Version: 0.2.0
+Version: 0.2.2
 Summary: Reusable synchronization engine and CLI for Last.fm, Libre.fm and GNU.fm networks.
 Keywords: lastfm,librefm,gnufm,scrobble,music
 Author: Hirad

{syncfm_core-0.2.0 → syncfm_core-0.2.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "syncfm-core"
-version = "0.2.0"
+version = "0.2.2"
 description = "Reusable synchronization engine and CLI for Last.fm, Libre.fm and GNU.fm networks."
 readme = "README.md"
 license = "GPL-3.0-or-later"

{syncfm_core-0.2.0 → syncfm_core-0.2.2}/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "syncfm-core"
-version = "0.2.0"
+version = "0.2.2"
 description = "Reusable synchronization engine and CLI for Last.fm, Libre.fm and GNU.fm networks."
 readme = "README.md"
 license = "GPL-3.0-or-later"

{syncfm_core-0.2.0 → syncfm_core-0.2.2}/src/syncfm_core/cli/dashboard.py

@@ -64,6 +64,7 @@ class _RecentScrobble:
     scrobble: Scrobble
     phase: SyncPhase
     completed: bool
+    failed: bool
 
 
 class RichProgressPresenter:
@@ -124,7 +125,7 @@ class RichProgressPresenter:
         self._task_id: TaskID | None = None
         self._rendered_phase: SyncPhase | None = None
         self._live: Live | None = None
-        self._last_plain_update: tuple[SyncPhase, int, int] | None = None
+        self._last_plain_update: tuple[SyncPhase, int, int, bool] | None = None
 
     def configure(self, *, source_label: str, target_label: str) -> None:
         """Update the source and target labels before rendering starts."""
@@ -364,11 +365,15 @@ class RichProgressPresenter:
             scrobble=scrobble,
             phase=progress.phase,
             completed=progress.current_scrobble_completed,
+            failed=progress.current_scrobble_failed,
         )
 
     @staticmethod
     def _recent_status(recent: _RecentScrobble) -> tuple[str, str]:
         """Return the label and Rich style for a recent-scrobble row."""
+        if recent.failed:
+            return "✗ FAILED", "bold red"
+
         if recent.completed:
             if recent.phase is SyncPhase.ENRICHING:
                 return "✓ READY", "bold green"
@@ -394,24 +399,43 @@ class RichProgressPresenter:
 
     def _render_plain_update(self, progress: SyncProgress) -> None:
         """Print concise progress when output is not an interactive terminal."""
-        snapshot = (progress.phase, progress.completed, progress.total)
+        snapshot = (
+            progress.phase,
+            progress.completed,
+            progress.total,
+            progress.current_scrobble_failed,
+        )
         phase_changed = (
             self._last_plain_update is None
             or self._last_plain_update[0] is not progress.phase
         )
-        phase_finished = progress.total > 0 and progress.completed == progress.total
+        phase_finished = 0 < progress.total == progress.completed
 
-        if not phase_changed and not phase_finished:
+        if (
+            not phase_changed
+            and not phase_finished
+            and not progress.current_scrobble_failed
+        ):
             return
 
         if snapshot == self._last_plain_update:
             return
 
         message = Text()
-        message.append("● ", style=self._phase_color())
-        message.append(_PHASE_LABELS[progress.phase])
+
+        if progress.current_scrobble_failed:
+            message.append("✗ ", style="bold red")
+            if progress.phase is SyncPhase.ENRICHING:
+                message.append("Metadata lookup failed", style="bold red")
+            else:
+                message.append("Scrobble submission failed", style="bold red")
+        else:
+            message.append("● ", style=self._phase_color())
+            message.append(_PHASE_LABELS[progress.phase])
+
         if progress.total > 0:
             message.append(f"  {progress.completed}/{progress.total}", style="dim")
+
         self._console.print(message)
         self._last_plain_update = snapshot
 
@@ -425,6 +449,8 @@ class RichProgressPresenter:
 
     def _phase_color(self) -> str:
         """Return a consistent color for the current phase."""
+        if self._latest.current_scrobble_failed:
+            return "red"
         if self._latest.phase is SyncPhase.COMPLETED:
             return "green"
         if self._latest.phase is SyncPhase.FAILED:
@@ -433,6 +459,9 @@ class RichProgressPresenter:
 
     def _activity_badge(self) -> str:
         """Return a short uppercase status for the current activity."""
+        if self._latest.current_scrobble_failed:
+            return "FAILED"
+
         if self._latest.current_scrobble_completed:
             if self._latest.phase is SyncPhase.ENRICHING:
                 return "READY"

{syncfm_core-0.2.0 → syncfm_core-0.2.2}/src/syncfm_core/models/sync_progress.py

@@ -16,6 +16,7 @@ class SyncProgress:
     total: int
     current_scrobble: Scrobble | None = None
     current_scrobble_completed: bool = False
+    current_scrobble_failed: bool = False
 
     def __post_init__(self) -> None:
         """Validate progress values."""
@@ -25,10 +26,15 @@ class SyncProgress:
             raise ValueError("total must be non-negative")
         if self.completed > self.total:
             raise ValueError("completed must not exceed total")
-        if self.current_scrobble_completed and self.current_scrobble is None:
+        if (
+            self.current_scrobble_completed or self.current_scrobble_failed
+        ) and self.current_scrobble is None:
             raise ValueError(
-                "Completed current-scrobble state requires a current scrobble."
+                "Completed or failed current-scrobble state requires a current scrobble."
             )
 
+        if self.current_scrobble_completed and self.current_scrobble_failed:
+            raise ValueError("A current scrobble cannot be both completed and failed.")
+
 
 type ProgressCallback = Callable[[SyncProgress], None]

{syncfm_core-0.2.0 → syncfm_core-0.2.2}/src/syncfm_core/networks/pylast_adapter.py

@@ -133,34 +133,58 @@ class PyLastNetworkAdapter:
         end_timestamp: int | None = None,
         limit: int | None = None,
     ) -> list[Scrobble]:
-        """Return scrobbles matching the supplied range or limit.
-
-        Args:
-            start_timestamp: Earliest playback timestamp to include.
-            end_timestamp: Latest playback timestamp to include.
-            limit: Maximum number of scrobbles to return.
+        """Return scrobbles within the inclusive timestamp range."""
+        api_start_timestamp = (
+            start_timestamp - 1
+            if start_timestamp is not None and start_timestamp > 0
+            else None
+        )
+        api_end_timestamp = (
+            end_timestamp + 1
+            if end_timestamp is not None
+            else None
+        )
 
-        Returns:
-            Matching playback events.
+        api_limit = (
+            None
+            if limit is not None
+            and (start_timestamp is not None or end_timestamp is not None)
+            else limit
+        )
 
-        Raises:
-            NetworkError: If pylast cannot retrieve playback history.
-            InvalidNetworkResponseError: If returned playback data is malformed.
-        """
         try:
             user = self._network.get_user(self._username)
             played_tracks = user.get_recent_tracks(
-                limit=limit,
-                time_from=start_timestamp,
-                time_to=end_timestamp,
+                limit=api_limit,
+                time_from=api_start_timestamp,
+                time_to=api_end_timestamp,
                 stream=False,
             )
-            return [
-                self._mapper.to_scrobble(played_track) for played_track in played_tracks
+            scrobbles = [
+                self._mapper.to_scrobble(played_track)
+                for played_track in played_tracks
             ]
         except pylast.PyLastError as error:
             raise self.translate_error(error) from error
 
+        filtered_scrobbles = [
+            scrobble
+            for scrobble in scrobbles
+            if (
+                start_timestamp is None
+                or scrobble.timestamp >= start_timestamp
+            )
+            and (
+                end_timestamp is None
+                or scrobble.timestamp <= end_timestamp
+            )
+        ]
+
+        if limit is not None:
+            return filtered_scrobbles[:limit]
+
+        return filtered_scrobbles
+
     def get_latest_scrobble_timestamp(self) -> int | None:
         """Return the latest scrobble timestamp, if one exists."""
         scrobbles = self.get_scrobbles(limit=1)

{syncfm_core-0.2.0 → syncfm_core-0.2.2}/src/syncfm_core/services/metadata_service.py

@@ -83,6 +83,12 @@ class MetadataService:
                     item.id,
                     self._error_message(error),
                 )
+                self._report_progress(
+                    completed,
+                    total,
+                    item.scrobble,
+                    current_scrobble_failed=True,
+                )
                 raise
 
             self._queue_repository.update_metadata(item.id, metadata)
@@ -103,6 +109,7 @@ class MetadataService:
         current_scrobble: Scrobble | None = None,
         *,
         current_scrobble_completed: bool = False,
+        current_scrobble_failed: bool = False,
     ) -> None:
         """Report metadata progress when a callback is configured."""
         if self._progress_callback is not None:
@@ -113,6 +120,7 @@ class MetadataService:
                     total=total,
                     current_scrobble=current_scrobble,
                     current_scrobble_completed=current_scrobble_completed,
+                    current_scrobble_failed=current_scrobble_failed,
                 )
             )
 

{syncfm_core-0.2.0 → syncfm_core-0.2.2}/src/syncfm_core/services/submission_service.py

@@ -82,6 +82,12 @@ class SubmissionService:
                     item.id,
                     self._error_message(error),
                 )
+                self._report_progress(
+                    completed,
+                    total,
+                    item.scrobble,
+                    current_scrobble_failed=True,
+                )
                 raise
 
             self._queue_repository.update_status(
@@ -101,6 +107,7 @@ class SubmissionService:
         current_scrobble: Scrobble | None = None,
         *,
         current_scrobble_completed: bool = False,
+        current_scrobble_failed: bool = False,
     ) -> None:
         """Report submission progress when a callback is configured."""
         if self._progress_callback is not None:
@@ -111,6 +118,7 @@ class SubmissionService:
                     total=total,
                     current_scrobble=current_scrobble,
                     current_scrobble_completed=current_scrobble_completed,
+                    current_scrobble_failed=current_scrobble_failed,
                 )
             )