pushframe 5.1.26__tar.gz → 5.1.28__tar.gz

{pushframe-5.1.26 → pushframe-5.1.28}/CHANGELOG.md

@@ -12,6 +12,59 @@ every channel.
 `pushframe` is an unofficial community CLI for Aura Frames digital photo
 frames; it is not affiliated with Aura Frames Inc.
 
+## [5.1.28] - 2026-10-04
+
+### Added
+
+- Scheduled `push` jobs (cron or hand-written units feeding a "buffet"
+  directory) take `--scheduled`/`--report-tag` and write the same run
+  bookkeeping as scheduled `google-sync`/`sync`: the `=== run … ===`
+  header with the job tag, the `=== run end rc=<rc> elapsed=<s>s ===`
+  footer, then the 5 MiB rotation. `push` stays purely additive —
+  bookkeeping only, no removal guard involved.
+
+## [5.1.27] - 2026-10-03
+
+### Fixed
+
+- `schedule add --sync-dir` units never ran: their ExecStart passed
+  `--scheduled`, which the `sync` parser never accepted — every tick died
+  with `unrecognized arguments: --scheduled` before any sync happened. The
+  parser now takes `--scheduled` and `--report-tag`.
+
+### Added
+
+- `status` flags any installed scheduled unit whose ExecStart the current
+  binary's argparse refuses (`⚠ would FAIL to start: …` with the exact
+  reason) — hand-edited or version-drifted units otherwise die on every
+  tick with nothing but journalctl to explain why. The same contract is
+  enforced offline by a test over every ExecStart `schedule_add` can
+  generate, and on the host by a deliberate `pytest -m live` check over
+  the real installed units.
+- Scheduled `sync` jobs (`--sync-dir`) write the same run bookkeeping as
+  scheduled `google-sync`: the `=== run … ===` header (with the job tag),
+  the `=== run end rc=<rc> elapsed=<s>s ===` footer, and the 5 MiB log
+  rotation — `<job>.log` alone answers which night synced what. Schedule
+  units now pass `--report-tag "<job>"`; `--report` (email) remains
+  google-sync-only.
+
+### Changed
+
+- Replaced the deprecated `datetime.utcnow()` in `get_utc_now()` with the
+  deprecation-free naive-UTC equivalent
+  (`datetime.now(timezone.utc).replace(tzinfo=None)`) — same value, same
+  naive contract every caller relies on (`parse_aura_dt` diffs,
+  `WriteBudget` arithmetic and its persisted `updated_at`).
+- Replaced Pydantic's deprecated `.dict()` with `.model_dump()` in the
+  API request-payload builders (`AssetApi.batch_update`,
+  `AssetApi.crop_asset`, `FrameApi.update_frame`) — Python 3.13-clean,
+  ready for Pydantic V3.
+- Job log rotation keeps a bounded history instead of a single generation:
+  past 5 MiB the log slides through `<job>.log.1` … `<job>.log.28`
+  (default; `PUSHFRAME_JOB_LOG_KEEP` tunes it), the oldest generation
+  falling off — several weeks of consultable history, worst case
+  `keep × 5 MiB` per job.
+
 ## [5.1.26] - 2026-10-03
 
 ### Added

{pushframe-5.1.26 → pushframe-5.1.28}/CLAUDE.md

@@ -137,7 +137,7 @@ Python toolchain, so we know exactly what survives before building anything new.
 - Partial model pattern via custom `AllOptional` metaclass (`meta.py`): `class FramePartial(Frame, metaclass=AllOptional)`
 - Enums used for known string-valued discriminators: `ActivityType`, `ReactionType`, `Feature`
 - Pydantic `@validator` used for cross-field validation: `AssetPartialId.check_id_or_local_id`
-- `.dict(include={...})` used to build API request payloads from model instances
+- `.model_dump(include={...})` used to build API request payloads from model instances
 ## Configuration
 - Credentials passed via env vars: `AURA_EMAIL`, `AURA_PASSWORD`
 - AWS pool IDs hardcoded as module constants (flagged as TODO to move to config)
@@ -172,7 +172,7 @@ Python toolchain, so we know exactly what survives before building anything new.
 ## Pattern Overview
 - `Aura` is the single public entry point; callers never instantiate API classes directly
 - Each `*Api` class is a thin wrapper over one REST resource domain with zero business logic of its own
-- Pydantic models serve as both validated DTOs and serialization targets (`.dict()` for request payloads, `**json_response` for hydration)
+- Pydantic models serve as both validated DTOs and serialization targets (`.model_dump()` for request payloads, `**json_response` for hydration)
 - AWS auth uses Cognito anonymous identity pools — no long-lived AWS credentials needed
 - All HTTP is synchronous (`httpx.Client`); the codebase has acknowledged debt to migrate to async
 ## Layers
@@ -231,7 +231,7 @@ Python toolchain, so we know exactly what survives before building anything new.
 - Pattern: Constructor injection of `Client`; no interface/protocol defined
 - Purpose: Validate, hydrate, and serialise API response JSON
 - Examples: `auraframes/models/frame.py`, `auraframes/models/asset.py`
-- Pattern: `Model(**json_response.get('key'))` for hydration; `.dict(include={...})` for request payloads
+- Pattern: `Model(**json_response.get('key'))` for hydration; `.model_dump(include={...})` for request payloads
 - Purpose: Generates a "partial" variant of any model (all fields become `Optional`) for PATCH-style updates
 - Examples: `auraframes/models/meta.py` — used by `FramePartial` in `auraframes/models/frame.py:93`
 - Pattern: `class FramePartial(Frame, metaclass=AllOptional): pass`

{pushframe-5.1.26 → pushframe-5.1.28}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: pushframe
-Version: 5.1.26
+Version: 5.1.28
 Summary: Unofficial community CLI for Aura Frames digital photo frames (sync a local folder or a Google Photos album; not affiliated with Aura Frames Inc.)
 Project-URL: Homepage, https://github.com/coredmp95/pushframe
 Project-URL: Repository, https://github.com/coredmp95/pushframe

{pushframe-5.1.26 → pushframe-5.1.28}/docs/CLI.md

@@ -633,7 +633,7 @@ The second run reports `To upload: 0` — the photo is re-shown, never uploaded
 usage: pushframe push [-h] --frame FRAME [--apply] [--yes] [--limit LIMIT]
                      [--batch-size BATCH_SIZE] [--chunk-delay CHUNK_DELAY]
                      [--max-wait MAX_WAIT] [--no-wait] [--country COUNTRY]
-                     [--ignore-budget]
+                     [--ignore-budget] [--scheduled] [--report-tag REPORT_TAG]
                      dir
 
 positional arguments:
@@ -652,12 +652,21 @@ options:
   --no-wait                Stop immediately instead of waiting when the write budget is exhausted
   --country COUNTRY        Override the expected account country for the geo pre-flight guard
   --ignore-budget          Escape hatch: bypass the write budget entirely for this run
+  --scheduled              Timed-run bookkeeping: the job log opens with a timestamped
+                           "=== run ... ===" header and closes with the rc/elapsed footer
+  --report-tag REPORT_TAG  Job identity in the log header and the log-rotation target
 ```
 
 `push` is **structurally additive**: the removal list is forced empty, so it can never hide,
 remove, or re-show anything. It is the safe way to add photos from a supply directory without
 the frame being diffed to match it.
 
+Cron-fed buffet frames: run `push ... --apply --yes --scheduled --report-tag <job>` from
+cron or a hand-written unit — the job log (`~/.local/state/pushframe/<job>.log` for units)
+then opens with a timestamped `=== run … ===` header, closes with `=== run end rc=<rc>
+elapsed=<s>s ===`, and rotates past 5 MiB (`PUSHFRAME_JOB_LOG_KEEP` tunes the depth), like
+every scheduled verb.
+
 ```bash
 pushframe push ./buffet --frame "Living Room"
 ```

{pushframe-5.1.26 → pushframe-5.1.28}/docs/ERRORS.md

@@ -104,6 +104,11 @@ chosen per job at install time with `schedule add … --report LEVEL`
 | `schedule add: --FLAG needs a value` / `unknown option "…"` / `… given twice` / `unexpected "…"` | The `schedule add` tail is malformed — a dangling flag, a typo in a flag name (they are listed), a duplicated flag, or a stray word | Read the message: it names the exact token and, for unknown options, lists the valid ones. Fixed in 5.1.22 — these used to crash with a raw traceback (pre-5.1.22) |
 | ``schedule list: unexpected "…" — `pushframe schedule list` takes no arguments`` / `schedule remove: unexpected "…" — usage: pushframe schedule remove <job>` | A stray extra word after the single argument these verbs take — exit 2, nothing listed or removed. Fixed in 5.1.25 — extras were ignored silently | `schedule list` takes no arguments; `schedule remove` takes exactly one job name |
 | A timer "fails" repeatedly | Read the job log | `~/.local/state/pushframe/<job>.log`; the unit ends on the first failure on purpose — the next tick is the retry |
+| `=== run 2026-10-04T00:02:59+02:00 job=nightly pushframe=5.1.26 ===` opens a job log, `=== run end rc=0 elapsed=42s ===` closes it | Every scheduled run stamps its log with its identity (when, which job, which pushframe — 5.1.26) and its outcome (exit code + duration). A missing footer means the run died by exception: the traceback and systemd's `Failed` line carry that story | Read `<job>.log` one block per run; `rc=0` = healthy. No footer → the traceback above it and `journalctl --user -u pushframe-<job>` tell the rest |
+| `  ~ <asset-id> (taken 2020-01-01) — re-show` / `  - <asset-id> (taken <date>)` lines under the plan | 5.1.26: a scheduled delta names WHICH frame assets it touches (the shape the interactive dry-run prints) — a delta is identifiable, not just countable | Check the ids against your expectations; `google-sync --pair <name>` without `--apply` shows the same plan interactively |
+| `<job>.log.1` (and `.log.2` … `.log.28`) appearing next to a job log | 5.1.27: past 5 MiB the log slides one generation older at run end, the oldest falling off — the live file stays bounded, weeks of history stay readable. Generations beyond a lowered keep are swept | Nothing — that is the size bound working. `PUSHFRAME_JOB_LOG_KEEP` tunes the depth (a junk value falls back to the default; a rotation failure never fails a run) |
+| A `--sync-dir` job that never ran, with `unrecognized arguments: --scheduled` in its log (pre-5.1.27) | The unit's ExecStart passed `--scheduled` before the `sync` parser accepted it — every tick died at argparse (exit 2) before any sync | Fixed in 5.1.27 — upgrade and the existing unit works as-is; re-add it (`schedule add --sync-dir …`) to also pick up `--report-tag` (named header + rotation) |
+| `⚠ would FAIL to start: unrecognized arguments: --nope — re-add the job …` under a job line in `pushframe status` | The unit's ExecStart uses a flag the CURRENT binary's argparse refuses — the job dies on every tick before doing anything (hand-edited unit, or a unit installed by a mismatched pushframe version). 5.1.27 | Fix the unit or re-add the job; `pushframe --version` against the unit's flags tells you which way the drift goes |
 
 ## Anything else
 

{pushframe-5.1.26 → pushframe-5.1.28}/pushframe/__init__.py

@@ -1,4 +1,4 @@
 # pushframe — unofficial community CLI for Aura Frames (not affiliated).
 # Version single source for the CLI surface (REL-02); pyproject keeps the
 # packaging metadata version and tests/test_version.py enforces lockstep.
-__version__ = "5.1.26"
+__version__ = "5.1.28"

{pushframe-5.1.26 → pushframe-5.1.28}/pushframe/api/assetApi.py

@@ -69,7 +69,7 @@ class AssetApi(BaseApi):
 
         json_response = self._client.put(f'/assets/batch_update.json', data={
             "assets": [
-                item.dict(
+                item.model_dump(
                     include={
                         'data_uti': True,
                         'favorite': True,
@@ -179,7 +179,7 @@ class AssetApi(BaseApi):
         :param asset: Asset containing new rotation/rect data.
         :return: The asset with modified crop fields.
         """
-        json_response = self._client.post(f'/assets/crop.json', data=asset.dict(
+        json_response = self._client.post(f'/assets/crop.json', data=asset.model_dump(
             include={
                 'id': True,
                 'local_identifier': True,

{pushframe-5.1.26 → pushframe-5.1.28}/pushframe/api/frameApi.py

@@ -145,7 +145,7 @@ class FrameApi(BaseApi):
         :return: Returns the hydrated frame with changes.
         """
         json_response = self._client.put(f'/frames/{frame_id}.json',
-                                         data={'frame': frame_partial.dict(exclude_unset=True)})
+                                         data={'frame': frame_partial.model_dump(exclude_unset=True)})
         return Frame(**json_response.get('frame'))
 
     def select_asset(self, frame_id: str, asset_partial_ids: AssetPartialId | list[AssetPartialId]) -> int:

{pushframe-5.1.26 → pushframe-5.1.28}/pushframe/cli.py

@@ -103,6 +103,18 @@ def build_parser() -> argparse.ArgumentParser:
     sync_parser.add_argument('--frame', required=True, help='Frame name (substring) or id')
     sync_parser.add_argument('--apply', action='store_true', default=False, help='Execute the plan (upload + delete) instead of only printing it')
     sync_parser.add_argument('--yes', action='store_true', default=False, help='Skip the confirmation prompt (required for --apply when running non-interactively)')
+    # Scheduled sync-dir jobs (pushframe schedule add ... --sync-dir) run
+    # through this verb, so it needs the same bookkeeping flags as scheduled
+    # google-sync. (Regression: units passed --scheduled before this parser
+    # accepted it -- every sync-dir tick died 'unrecognized arguments'.)
+    sync_parser.add_argument('--scheduled', action='store_true', default=False,
+                             help='Timed-run bookkeeping: the job log opens with a '
+                                  'timestamped "=== run ... ===" header and closes with '
+                                  'the rc/elapsed footer (used by pushframe schedule units)')
+    sync_parser.add_argument('--report-tag', default=None, dest='report_tag',
+                             help='Job identity in the log header and the log-rotation '
+                                  'target (schedule units pass the job name; sync jobs '
+                                  'have no --report email)')
     # The three tiers of "no longer in the local directory" (D-02/D-03).
     # Hiding is the default because the frame has no photo-count limit, so a
     # mistaken sync should cost visibility, never photos. argparse enforces
@@ -136,6 +148,15 @@ def build_parser() -> argparse.ArgumentParser:
     push_parser.add_argument('--no-wait', action='store_true', default=False, help='Stop immediately instead of waiting when the write budget is exhausted')
     push_parser.add_argument('--country', default=None, help='Override the expected account country for the geo pre-flight guard (default from PUSHFRAME_COUNTRY, legacy AURA_COUNTRY)')
     push_parser.add_argument('--ignore-budget', action='store_true', default=False, dest='ignore_budget', help='Escape hatch: bypass the write budget entirely for this run')
+    # Scheduled push jobs (cron or hand-written units feeding a "buffet"
+    # directory) get the same log bookkeeping as scheduled sync/google-sync.
+    push_parser.add_argument('--scheduled', action='store_true', default=False,
+                             help='Timed-run bookkeeping: the job log opens with a '
+                                  'timestamped "=== run ... ===" header and closes with '
+                                  'the rc/elapsed footer')
+    push_parser.add_argument('--report-tag', default=None, dest='report_tag',
+                             help='Job identity in the log header and the log-rotation '
+                                  'target (crons and units pass a job name)')
 
     # `reconcile` = data hygiene on EXISTING stuck placeholder rows (REL-05,
     # D-13) -- deliberately outside the sync/push loop. Report-only by
@@ -1076,6 +1097,7 @@ def _schedule_status_section() -> list[str]:
     for svc_path in services:
         job = svc_path.stem.replace('pushframe-', '')
         what = '(unreadable unit)'
+        exec_line = ''
         try:
             unit_text = svc_path.read_text(encoding='utf-8')
             exec_line = next((l for l in unit_text.splitlines()
@@ -1085,10 +1107,64 @@ def _schedule_status_section() -> list[str]:
             pass
         when = next_fire.get(f'pushframe-{job}.timer', '(timer not enabled)')
         lines.append(f'  {job}: {what} — next: {when}')
+        if exec_line:
+            try:
+                problem = _unit_argv_parse_problem(exec_line)
+            except Exception:
+                problem = None  # status degrades; it never fails here
+            if problem:
+                lines.append(f'    ⚠ would FAIL to start: {problem} — '
+                             f're-add the job (`pushframe schedule add ...`) '
+                             f'or fix the unit')
     lines.append('  (detail: `pushframe schedule list`)')
     return lines
 
 
+def _unit_argv_parse_problem(exec_line: str) -> str | None:
+    """Would this unit's ExecStart survive the CURRENT binary's argparse?
+
+    The tokens from the verb onward go through the real parser
+    (parse_known_args): unrecognized flags, missing required arguments or
+    invalid values surface here as a one-line reason — None when the
+    command line is accepted verbatim. This is the guard against the
+    sync-dir class of breakage (units installed passing a flag the parser
+    of the day rejects die on EVERY tick — argparse exit 2, before any
+    sync — with nothing but journalctl to explain why): hand-edited units
+    and version drift (unit newer or older than the binary) are exactly
+    what it surfaces. Never raises — status degrades, it does not fail.
+    """
+    import contextlib
+    import io
+    import shlex
+    body = exec_line.removeprefix('ExecStart=')
+    try:
+        tokens = shlex.split(body)
+    except ValueError:
+        return 'ExecStart is not shell-quoted correctly'
+    parser = build_parser()
+    try:
+        sub = next(a for a in parser._actions if a.dest == 'command')
+        verbs = set(sub.choices)
+    except Exception:
+        return None  # cannot introspect the parser — refuse to guess
+    verb_idx = next((i for i, t in enumerate(tokens) if t in verbs), None)
+    if verb_idx is None:
+        return 'no pushframe command found in ExecStart'
+    argv = tokens[verb_idx:]
+    err = io.StringIO()
+    try:
+        with contextlib.redirect_stderr(err):
+            _, extras = parser.parse_known_args(argv)
+    except SystemExit:
+        detail = err.getvalue().split('error:', 1)[-1]
+        detail = ' '.join(detail.split())[:160]
+        return f'argparse refused: {detail}' if detail \
+            else 'argparse refused the command line'
+    if extras:
+        return f'unrecognized arguments: {" ".join(map(str, extras))[:160]}'
+    return None
+
+
 def _frame_flag_needs_value(rest: list[str], flag: str) -> bool:
     """True when `flag` is present but dangling (last token, or followed by
     another --flag) — the ExecStart parser's guard against indexing past
@@ -2212,23 +2288,68 @@ def _scheduled_run_footer(rc: int, elapsed_s: float) -> None:
     print(f'=== run end rc={rc} elapsed={round(elapsed_s)}s ===')
 
 
+JOB_LOG_KEEP_GENERATIONS = 28
+
+
+def _job_log_keep() -> int:
+    """Ops knob for the rotation history depth: PUSHFRAME_JOB_LOG_KEEP.
+    A junk or <1 value falls back to the default — a retention typo must
+    never fail a run that already succeeded (this function's only contract).
+    """
+    try:
+        keep = int(os.getenv('PUSHFRAME_JOB_LOG_KEEP', ''))
+    except ValueError:
+        return JOB_LOG_KEEP_GENERATIONS
+    return keep if keep >= 1 else JOB_LOG_KEEP_GENERATIONS
+
+
 def _rotate_job_log_if_large(report_tag: str | None, *,
-                             limit_bytes: int = 5 * 1024 * 1024) -> bool:
-    """Bound a job's append log (systemd reopens it with O_APPEND every
-    start): past `limit_bytes`, the log slides to <job>.log.1 — one
-    previous generation kept. Called at run END: this process's still-open
-    stdout fd keeps appending to the renamed inode until exit, and the next
-    start opens a fresh <job>.log, so nothing is lost and no fd surgery is
-    needed. A rotation failure must never fail a run that already succeeded.
+                             limit_bytes: int = 5 * 1024 * 1024,
+                             keep: int | None = None) -> bool:
+    """Bound a job's append log while keeping history consultable (systemd
+    reopens the file with O_APPEND every start): past `limit_bytes`, the log
+    slides one generation older — <job>.log.1 … <job>.log.<keep>, the oldest
+    generation falling off the end — so the live file stays bounded AND the
+    previous weeks remain readable. Generations are size-bounded, not
+    time-bounded: a nightly job crossing the limit every night keeps ~4
+    weeks (default 28); a quiet one keeps months. Worst case per job:
+    keep × limit bytes. Called at run END: this process's still-open stdout
+    fd keeps appending to the renamed inode until exit, and the next start
+    opens a fresh <job>.log, so nothing is lost and no fd surgery is needed.
+    A rotation failure must never fail a run that already succeeded.
     """
     if not report_tag:
         return False
+    if keep is None:
+        keep = _job_log_keep()
+    if keep < 1:
+        raise ValueError(f'keep={keep!r} must be >= 1')
     from pushframe.schedule import LOG_DIR
     log = LOG_DIR / f'{report_tag}.log'
     try:
         if not log.exists() or log.stat().st_size <= limit_bytes:
             return False
+        # Slide every existing generation one slot older, oldest falling off
+        # (os.replace overwrites the destination): .log.(keep-1) -> .log.keep,
+        # ..., .log.1 -> .log.2, then the live log -> .log.1.
+        for slot in range(keep - 1, 0, -1):
+            src = log.parent / f'{log.name}.{slot}'
+            if src.exists():
+                os.replace(src, log.parent / f'{log.name}.{slot + 1}')
         os.replace(log, log.parent / (log.name + '.1'))
+        # Generations beyond `keep` can only exist after an operator LOWERED
+        # the retention (env or code); leftovers would linger as unbounded
+        # silent tails, so sweep them — tolerantly, same run-success rule.
+        try:
+            prefix = log.name + '.'
+            for stale in log.parent.iterdir():
+                if not stale.name.startswith(prefix):
+                    continue
+                suffix = stale.name[len(prefix):]
+                if suffix.isdigit() and int(suffix) > keep:
+                    stale.unlink()
+        except OSError:
+            pass
         return True
     except OSError:
         return False
@@ -2398,16 +2519,40 @@ def _main(argv=None) -> int:
         return run_inspect(args.frame, debug=args.debug)
     if args.command == 'sync':
         removal_mode = 'hard_delete' if args.hard_delete else ('delete' if args.delete else 'hide')
-        return run_sync(args.dir, args.frame, apply=args.apply, yes=args.yes, debug=args.debug,
-                        removal_mode=removal_mode)
+        import time as _time
+        if args.scheduled:
+            _scheduled_run_header(args.report_tag)
+        _t0 = _time.monotonic()
+        rc = run_sync(args.dir, args.frame, apply=args.apply, yes=args.yes, debug=args.debug,
+                      removal_mode=removal_mode)
+        if args.scheduled:
+            # Same bookkeeping contract as scheduled google-sync: the job
+            # log carries the run's identity (header above), end (rc +
+            # elapsed), then the size bound — <job>.log alone answers which
+            # night synced what.
+            _scheduled_run_footer(rc, _time.monotonic() - _t0)
+            _rotate_job_log_if_large(args.report_tag)
+        return rc
     if args.command == 'push':
-        return run_sync(
+        import time as _time
+        if args.scheduled:
+            _scheduled_run_header(args.report_tag)
+        _t0 = _time.monotonic()
+        rc = run_sync(
             args.dir, args.frame, apply=args.apply, yes=args.yes, debug=args.debug,
             no_delete=True, limit=args.limit, batch_size=args.batch_size,
             chunk_delay=args.chunk_delay, verb='push',
             max_wait=args.max_wait, no_wait=args.no_wait,
             country=args.country, ignore_budget=args.ignore_budget,
         )
+        if args.scheduled:
+            # Same bookkeeping contract as scheduled google-sync/sync: the
+            # job log carries the run's identity (header above), end (rc +
+            # elapsed), then the size bound. push is purely additive, so
+            # there is no mass-hide guard to check — bookkeeping only.
+            _scheduled_run_footer(rc, _time.monotonic() - _t0)
+            _rotate_job_log_if_large(args.report_tag)
+        return rc
     if args.command == 'reconcile':
         return run_reconcile(
             args.frame, remove=args.remove, yes=args.yes, mechanism=args.mechanism,

{pushframe-5.1.26 → pushframe-5.1.28}/pushframe/schedule.py

@@ -132,8 +132,12 @@ def _exec_start_for(pair: str | None = None, album: str | None = None,
     from pushframe import config_store
     parts = [_pushframe_command()]
     if sync_dir:
+        # --report-tag carries the job identity into the run's log header
+        # and its rotation (sync jobs have no --report email; the tag is
+        # what makes <job>.log self-describing).
         parts += ['sync', f'"{sync_dir}"', f'--frame "{frame}"',
-                  '--apply', '--yes', '--scheduled']
+                  '--apply', '--yes', '--scheduled',
+                  '--report-tag', f'"{job}"']
     else:
         spec = (config_store.load().get('pairs', {}) or {}).get(pair or '', {})
         album = spec.get('album', album)

pushframe-5.1.28/pushframe/utils/dt.py

@@ -0,0 +1,27 @@
+from datetime import datetime, timezone
+
+AURA_DT_FORMAT = '%Y-%m-%dT%H:%M:%S.%fZ'
+
+
+def parse_aura_dt(aura_dt_str: str):
+    return datetime.strptime(aura_dt_str, AURA_DT_FORMAT)
+
+
+def get_utc_now():
+    """Naive UTC now -- the exact value `datetime.utcnow()` used to return.
+
+    Deliberately NAIVE, not `datetime.now(timezone.utc)`: every consumer
+    subtracts this from naive datetimes or stores it next to them --
+    `find_placeholders` diffs it against `parse_aura_dt` results (strptime
+    is naive) and `WriteBudget.acquire` does `(now - updated_at)` arithmetic
+    on a value persisted via isoformat round-trip. One aware datetime in
+    that pipeline raises `TypeError: can't subtract offset-naive and
+    offset-aware datetimes`. `datetime.now(timezone.utc).replace(tzinfo=None)`
+    is the deprecation-free equivalent Python recommends for the old
+    `utcnow()` semantics (no wall-clock read, immune to NTP/adjtime jumps).
+    """
+    return datetime.now(timezone.utc).replace(tzinfo=None)
+
+
+def format_dt_to_aura(dt: datetime):
+    return dt.strftime(AURA_DT_FORMAT)

{pushframe-5.1.26 → pushframe-5.1.28}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pushframe"
-version = "5.1.26"
+version = "5.1.28"
 description = "Unofficial community CLI for Aura Frames digital photo frames (sync a local folder or a Google Photos album; not affiliated with Aura Frames Inc.)"
 readme = "README.md"
 requires-python = ">=3.14"

{pushframe-5.1.26 → pushframe-5.1.28}/tests/test_asset_partial.py

@@ -21,7 +21,7 @@ from pydantic import ValidationError
 
 from pushframe.models.asset import Asset, AssetPartial, AssetPartialId
 
-# The exact allowlist AssetApi.batch_update uses for its `.dict(include=...)`
+# The exact allowlist AssetApi.batch_update uses for its `.model_dump(include=...)`
 # call (pushframe/api/assetApi.py:19-38) -- AssetPartial must serialize to
 # precisely this shape.
 BATCH_UPDATE_ALLOWLIST = {
@@ -51,7 +51,7 @@ def test_asset_partial_constructs_with_id_unset():
 
 
 def test_asset_partial_serializes_to_batch_update_payload_shape():
-    """.dict(include=...) over batch_update's allowlist returns exactly
+    """.model_dump(include=...) over batch_update's allowlist returns exactly
     those keys, regardless of which fields were actually set."""
     partial = AssetPartial(
         local_identifier='local-id-1',
@@ -65,7 +65,7 @@ def test_asset_partial_serializes_to_batch_update_payload_shape():
         upload_priority=1,
     )
 
-    payload = partial.dict(include=BATCH_UPDATE_ALLOWLIST)
+    payload = partial.model_dump(include=BATCH_UPDATE_ALLOWLIST)
 
     assert set(payload.keys()) == set(BATCH_UPDATE_ALLOWLIST.keys())
     assert payload['local_identifier'] == 'local-id-1'