napper-sync 0.1.0__py3-none-any.whl

napper_sync/sources.py

@@ -0,0 +1,81 @@
+"""File-based sources: CSV and JSON.
+
+Both share one row format - the fixed columns ``start``, ``end``,
+``category``, ``comment``, and any further column is taken as a
+category-specific field::
+
+    start,end,category,comment,feedingAmount,bottleFeedingType,diaperContent
+    2026-09-17T13:10:00,2026-09-17T14:35:00,nap,,,,
+    2026-09-17T15:00:00,,bottle,,120,FORMULA,
+    2026-09-17T15:30:00,,diaper,,,,WET
+
+Empty cells are ignored. Categories may be given by API name or alias. An
+optional ``id`` column (``LOG_<uuid>_<CATEGORY>``) pins the Napper ID, which
+makes a repeated import of the same file update instead of duplicate.
+
+A JSON file holds a list of objects with the same keys; extra fields may sit
+next to the fixed ones or be grouped under ``"fields"``. That is the hook
+for anything else - another tracker, a Home Assistant export, a sensor
+script: whatever can write such a list can feed Napper.
+"""
+
+from __future__ import annotations
+
+import csv
+import json
+from collections.abc import Callable
+from pathlib import Path
+
+from .sync import Entry, parse_time
+
+FIXED_COLUMNS = {"id", "start", "end", "category", "comment"}
+
+
+def from_csv(path: Path) -> list[Entry]:
+    out: list[Entry] = []
+    with Path(path).open(newline="", encoding="utf-8-sig") as fh:
+        for row in csv.DictReader(fh):
+            if not (row.get("start") or "").strip():
+                continue
+            out.append(_build(row))
+    return out
+
+
+def from_json(path: Path) -> list[Entry]:
+    data = json.loads(Path(path).read_text(encoding="utf-8"))
+    if not isinstance(data, list):
+        raise ValueError("JSON source must be a list of entries")
+    return [_build(d) for d in data]
+
+
+def _build(raw: dict) -> Entry:
+    fields = dict(raw.get("fields") or {})
+    for key, value in raw.items():
+        if key in FIXED_COLUMNS or key == "fields":
+            continue
+        if value is None or (isinstance(value, str) and not value.strip()):
+            continue
+        fields[key] = value
+    return Entry(
+        start=parse_time(raw["start"]),
+        end=parse_time(raw["end"]) if str(raw.get("end") or "").strip() else None,
+        category=str(raw.get("category") or "NAP"),
+        comment=str(raw.get("comment") or "").strip(),
+        fields=fields,
+        log_id=str(raw.get("id") or "").strip() or None,
+    )
+
+
+SOURCES: dict[str, Callable[[Path], list[Entry]]] = {
+    "csv": from_csv,
+    "json": from_json,
+}
+
+
+def load(path: Path, fmt: str | None = None) -> list[Entry]:
+    """Load a file, picking the parser from ``fmt`` or the file extension."""
+    path = Path(path)
+    fmt = (fmt or path.suffix.lstrip(".")).lower()
+    if fmt not in SOURCES:
+        raise ValueError(f"Unknown source format '{fmt}'. Known: {', '.join(SOURCES)}")
+    return SOURCES[fmt](path)

napper_sync/sync.py

@@ -0,0 +1,270 @@
+"""The sync core: entries, duplicate detection, and the write loop.
+
+A sync run is deliberately boring:
+
+1. a *source* yields :class:`Entry` objects (CSV, JSON, Famly, ...)
+2. the entries already in Napper for that period are fetched
+3. anything that is already there is skipped
+4. the rest is written
+
+Because of step 3 a repeated run is harmless, which is what makes an hourly
+timer safe. Writing is opt-in (``live=True``); the default is a dry run.
+"""
+
+from __future__ import annotations
+
+import logging
+from collections.abc import Iterable
+from dataclasses import dataclass, field
+from datetime import datetime, timedelta
+
+from . import categories
+from .napper import NapperClient, decode_comment
+
+log = logging.getLogger(__name__)
+
+# Two entries of the same category count as the same if their start times are
+# closer than this - or if their spans overlap.
+FUZZ = timedelta(minutes=10)
+
+
+@dataclass
+class Entry:
+    start: datetime
+    end: datetime | None = None
+    category: str = "NAP"
+    comment: str = ""
+    fields: dict = field(default_factory=dict)
+    log_id: str | None = None  # a stable ID makes a repeated write an update
+    raw: dict | None = field(default=None, repr=False, compare=False)  # as read from Napper
+
+    def __post_init__(self) -> None:
+        cat = categories.get(self.category)
+        self.category = cat.name
+        self.fields = categories.validate(cat.name, self.fields)
+        if not cat.span:
+            self.end = self.start
+        elif self.end and self.end <= self.start:
+            raise ValueError(
+                f"{self.category}: end is not after start ({self.start} -> {self.end})"
+            )
+
+    @property
+    def cat(self) -> categories.Category:
+        return categories.CATEGORIES[self.category]
+
+    def label(self) -> str:
+        text = f"{self.category} {self.start:%Y-%m-%d %H:%M}"
+        if self.cat.span:
+            text += f" -> {self.end:%H:%M}" if self.end else " (open)"
+        if self.fields:
+            text += "  " + " ".join(f"{k}={v}" for k, v in self.fields.items())
+        if self.comment:
+            text += f'  "{self.comment}"'
+        return text
+
+    @classmethod
+    def from_napper(cls, item: dict) -> Entry:
+        """An entry as it exists in Napper.
+
+        Fields are taken as they are, not validated: a value this version
+        does not know must not make the entry invisible to duplicate
+        detection.
+        """
+        cat = categories.CATEGORIES[str(item.get("category") or "").upper()]
+        entry = cls(
+            start=parse_time(item["start"]),
+            end=parse_time(item["end"]) if item.get("end") else None,
+            category=cat.name,
+            comment=decode_comment(item.get("comment")),
+            log_id=str(item.get("id") or "") or None,
+            raw=item,
+        )
+        entry.fields = {f.name: item[f.name] for f in cat.fields if f.name in item}
+        return entry
+
+
+@dataclass
+class SyncResult:
+    written: int
+    skipped: int
+    new: list[Entry]
+    live: bool
+    updated: int = 0
+    changed: list[tuple[Entry, list[str]]] = field(default_factory=list)
+
+    @property
+    def planned(self) -> int:
+        """Entries a live run would write: new ones plus corrections."""
+        return len(self.new) + len(self.changed)
+
+
+def parse_time(value) -> datetime:
+    """ISO string -> timezone-aware datetime.
+
+    A value without a zone is taken as local time - which is what you want
+    for hand-written timestamps in a CSV.
+    """
+    if isinstance(value, datetime):
+        return value.astimezone()
+    return datetime.fromisoformat(str(value).strip().replace("Z", "+00:00")).astimezone()
+
+
+def existing_entries(
+    client: NapperClient, baby_id: str, first: datetime, last: datetime
+) -> list[Entry]:
+    """Fetch what is already logged in Napper for the period, with a day of
+    slack on either side for timezone edges."""
+    raw = client.logs_between(
+        baby_id,
+        (first.date() - timedelta(days=1)).isoformat(),
+        (last.date() + timedelta(days=1)).isoformat(),
+    )
+    out: list[Entry] = []
+    for item in raw:
+        cat = (item.get("category") or "").upper()
+        if cat not in categories.CATEGORIES or not item.get("start"):
+            continue
+        try:
+            out.append(Entry.from_napper(item))
+        except (ValueError, KeyError):
+            continue  # tolerate malformed historical data
+    return out
+
+
+def is_duplicate(candidate: Entry, existing: Iterable[Entry]) -> bool:
+    for other in existing:
+        if other.category != candidate.category:
+            continue
+        # Day markers: one per day, so the same day already counts.
+        if candidate.cat.id_scheme == "date":
+            if other.start.date() == candidate.start.date():
+                return True
+            continue
+        if abs(other.start - candidate.start) <= FUZZ:
+            return True
+        if (
+            candidate.cat.span
+            and candidate.end
+            and other.end
+            and candidate.start < other.end
+            and other.start < candidate.end
+        ):
+            return True
+    return False
+
+
+def changes(candidate: Entry, other: Entry) -> list[str]:
+    """What writing ``candidate`` would change on ``other`` (same ID).
+
+    Only what the source owns is compared: start, end, comment and the
+    fields the source sets. Anything else on the Napper entry is left alone.
+    An empty list means there is nothing to do.
+    """
+    out: list[str] = []
+    if _ms(candidate.start) != _ms(other.start):
+        out.append(f"start {other.start:%H:%M} -> {candidate.start:%H:%M}")
+    if candidate.cat.span and _ms(candidate.end) != _ms(other.end):
+        out.append(f"end {_hm(other.end)} -> {_hm(candidate.end)}")
+    if candidate.comment != other.comment:
+        out.append(f"comment {other.comment!r} -> {candidate.comment!r}")
+    for name, value in candidate.fields.items():
+        if other.fields.get(name) != value:
+            out.append(f"{name} {other.fields.get(name)} -> {value}")
+    return out
+
+
+def _ms(dt: datetime | None) -> datetime | None:
+    """Napper stores milliseconds; compare at that precision."""
+    return dt if dt is None else dt.replace(microsecond=dt.microsecond // 1000 * 1000)
+
+
+def _hm(dt: datetime | None) -> str:
+    return f"{dt:%H:%M}" if dt else "open"
+
+
+def sync(
+    client: NapperClient, baby_id: str, entries: list[Entry], *, live: bool = False, report=print
+) -> SyncResult:
+    """Write the entries that are not in Napper yet.
+
+    ``report`` receives human-readable progress lines; pass a no-op to keep
+    the run quiet.
+    """
+    if not entries:
+        report("Source returned nothing.")
+        return SyncResult(0, 0, [], live)
+
+    first = min(e.start for e in entries)
+    last = max((e.end or e.start) for e in entries)
+    report(f"Source: {len(entries)} entries from {first:%Y-%m-%d} to {last:%Y-%m-%d}")
+
+    existing = existing_entries(client, baby_id, first, last)
+    by_id = {e.log_id: e for e in existing if e.log_id}
+    report(f"Already in Napper for that period: {len(existing)} logs")
+
+    # Three outcomes per source entry:
+    #   same ID already in Napper  -> correction if anything the source owns differs
+    #   same category close by     -> duplicate, left alone (older imports, manual entries)
+    #   otherwise                  -> new
+    # Decided incrementally so that two near-identical entries in the *source*
+    # also collapse into one - not only duplicates of what Napper already has.
+    new: list[Entry] = []
+    corrections: list[tuple[Entry, Entry, list[str]]] = []
+    for entry in sorted(entries, key=lambda e: e.start):
+        other = by_id.get(entry.log_id) if entry.log_id else None
+        if other is not None:
+            diff = changes(entry, other) if other.raw is not None else []
+            if diff:
+                corrections.append((entry, other, diff))
+            continue
+        if is_duplicate(entry, existing):
+            continue
+        new.append(entry)
+        existing.append(entry)
+        if entry.log_id:
+            by_id[entry.log_id] = entry
+    skipped = len(entries) - len(new) - len(corrections)
+    report(f"To write: {len(new)} new, {len(corrections)} to correct  (unchanged: {skipped})")
+
+    written = updated = 0
+    for entry in new:
+        result = client.create_log(
+            baby_id,
+            entry.category,
+            entry.start,
+            entry.end,
+            fields=entry.fields,
+            comment=entry.comment,
+            log_id=entry.log_id,
+            dry_run=not live,
+        )
+        if live:
+            report(f"  written: {entry.label()}   id={result['log_id']}")
+            written += 1
+        else:
+            report(f"  [dry-run] {entry.label()}")
+    for entry, other, diff in corrections:
+        result = client.update_log(
+            baby_id,
+            other.raw or {},
+            start=entry.start,
+            end=entry.end,
+            fields=entry.fields,
+            comment=entry.comment,
+            dry_run=not live,
+        )
+        what = "; ".join(diff)
+        if live:
+            report(f"  corrected: {entry.label()}   id={result['log_id']}  ({what})")
+            updated += 1
+        else:
+            report(f"  [dry-run] correct {entry.label()}  ({what})")
+
+    if live:
+        report(f"\nDone: {written} entries written, {updated} corrected.")
+    else:
+        report("\nDry run - nothing was written. Pass --live to write.")
+    return SyncResult(
+        written, skipped, new, live, updated, [(e, diff) for e, _, diff in corrections]
+    )

napper_sync-0.1.0.dist-info/METADATA

@@ -0,0 +1,223 @@
+Metadata-Version: 2.4
+Name: napper-sync
+Version: 0.1.0
+Summary: Unofficial Napper baby-tracker API client, and a sync that imports what the nursery logs in Famly.
+Author: Patrick Wuestling
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/PW-CODING/napper-sync
+Project-URL: Issues, https://github.com/PW-CODING/napper-sync/issues
+Project-URL: Documentation, https://github.com/PW-CODING/napper-sync/tree/main/docs
+Project-URL: Changelog, https://github.com/PW-CODING/napper-sync/blob/main/CHANGELOG.md
+Keywords: napper,famly,baby,baby-tracker,sleep-tracker,nursery,daycare,childcare,kita,krippe,sync,api-client
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Home Automation
+Classifier: Topic :: Utilities
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == "dev"
+Requires-Dist: ruff>=0.6; extra == "dev"
+Dynamic: license-file
+
+# napper-sync
+
+**Sync what your nursery logs in [Famly](https://famly.co) - naps, meals, diaper
+changes - into the [Napper](https://napper.app) baby tracker, automatically. Also an
+unofficial Python client for the Napper API.**
+
+[![CI](https://github.com/PW-CODING/napper-sync/actions/workflows/ci.yml/badge.svg)](https://github.com/PW-CODING/napper-sync/actions/workflows/ci.yml)
+![Python 3.11+](https://img.shields.io/badge/python-3.11%2B-blue)
+![License: MIT](https://img.shields.io/badge/license-MIT-green)
+
+**Auf Deutsch:** Überträgt automatisch, was die Kita in Famly einträgt - Schlaf, Mahlzeiten
+und Windelwechsel - in die Baby-App Napper. Kein Abtippen am Abend, keine Duplikate, und
+nachträgliche Korrekturen der Kita werden übernommen. Läuft per Zeitplan auf einem
+Raspberry Pi oder jedem anderen Rechner und braucht nur die Python-Standardbibliothek.
+Die Dokumentation ist englisch, Fragen und Issues gern auch auf Deutsch.
+
+Napper is a sleep-and-care tracker for babies. Famly is the app many nurseries
+use to tell parents what happened during the day. If your child is in a
+Famly nursery and you track at home with Napper, you end up typing the
+nursery's entries into Napper by hand every evening. This tool does that for
+you, every hour, without creating duplicates.
+
+Along the way it documents two APIs that have no public documentation - see
+[`docs/`](https://github.com/PW-CODING/napper-sync/tree/main/docs).
+
+> **Disclaimer.** This project is not affiliated with, endorsed by, or supported by
+> Napper AB or Famly ApS. It talks to private, undocumented APIs that the official
+> apps use internally. Those APIs may change or disappear with any app update, and
+> using them may not be covered by the services' terms - check the terms that apply
+> to your account before you decide. Use it with your own account, for your own
+> child, at your own risk; how you use it is your responsibility.
+
+## What it does
+
+- **Napper API client** - log in with the e-mailed one-time code, read the
+  history, write and delete entries in all eleven categories Napper knows
+  (nap, bedtime, woke up, night waking, nursing, bottle, solids, pumping,
+  diaper, temperature, medicine), with field validation before anything is sent.
+- **Famly → Napper sync** - reads the nursery's daily events and creates the
+  matching Napper entries, marked `(Famly)` so you can tell them apart. When
+  the nursery corrects an entry later, the Napper entry follows.
+- **Safe by default** - every write is a dry run unless you pass `--live`;
+  duplicate detection makes repeated runs harmless; the Napper rate limit is
+  handled with back-off.
+- **File import** - CSV or JSON for anything else you want to get into Napper.
+- **Unattended operation** - systemd timer, Discord notifications on failure
+  and on successful imports, tokens refreshed automatically.
+
+Standard library only; no runtime dependencies.
+
+## Install
+
+```bash
+pipx install git+https://github.com/PW-CODING/napper-sync
+# or
+pip install --user git+https://github.com/PW-CODING/napper-sync
+```
+
+Requires Python 3.11+.
+
+## Quick start
+
+```bash
+napper-sync login you@example.com     # Napper e-mails a code; paste it
+napper-sync babies                    # find your baby's ID
+napper-sync config init               # write ~/.config/napper-sync/config.toml
+#   -> put the baby ID into [napper] baby_id
+
+napper-sync logs 2026-09-01 2026-09-07          # read a week
+napper-sync add nap 2026-09-18T13:00 2026-09-18T14:20          # dry run
+napper-sync add nap 2026-09-18T13:00 2026-09-18T14:20 --live   # write
+napper-sync add diaper 2026-09-18T15:30 --set diaperContent=WET --live
+napper-sync add medicine 2026-09-18T19:00 --comment "Vitamin D" --live
+napper-sync categories                # every category, field and allowed value
+```
+
+### Famly sync
+
+```bash
+napper-sync famly token <VALUE>       # from localStorage["famly.accessToken"] in a logged-in browser
+napper-sync famly children            # -> [famly] child_id in the config
+napper-sync famly calendar 2026-09-14 2026-09-18    # what the nursery logged
+
+napper-sync sync-famly                # dry run: shows what would be written
+napper-sync sync-famly --live         # write it
+```
+
+To run this hourly on a Raspberry Pi with Discord alerts, see
+[`docs/deployment.md`](https://github.com/PW-CODING/napper-sync/blob/main/docs/deployment.md).
+
+### Importing a file
+
+```bash
+napper-sync sync-file entries.csv --live
+```
+
+Columns `start,end,category,comment` plus any category field as a further
+column; see [`examples/entries.example.csv`](https://github.com/PW-CODING/napper-sync/blob/main/examples/entries.example.csv).
+An optional `id` column pins the Napper ID, so importing a corrected file
+updates the entries instead of duplicating them.
+Categories accept English or German short names (`nap`/`nickerchen`,
+`diaper`/`windel`, `bottle`/`flasche`, …).
+
+## How it stays safe
+
+| Risk | Answer |
+|---|---|
+| Writing by accident | every write and delete is a dry run without `--live` |
+| Duplicates from repeated runs | Famly entries get a stable ID derived from child, category and start, so a repeated run rewrites the same entry instead of adding one; everything else is skipped if the same category exists within 10 minutes or overlaps; day markers are one-per-day |
+| Corrections at the nursery | a changed end time, note or diaper content overwrites the Napper entry on the next run; fields added by hand in the app are kept |
+| Hammering the API | 429 responses are parsed and retried with the server's requested delay |
+| Bad data | field names, enum values and ranges are validated locally before a request is built |
+| Silent breakage | Discord message on expired token, failed write, crashed run; unknown Famly event types are listed, never dropped |
+
+## Project layout
+
+```
+src/napper_sync/
+  napper.py          Napper API client (auth, read, write, delete)
+  categories.py      what each category expects - the data model
+  sync.py            Entry, duplicate detection, the sync loop
+  sources.py         CSV / JSON sources
+  famly.py           Famly API client
+  famly_mapping.py   Famly events -> Napper entries
+  notify.py          Discord webhook
+  config.py          ~/.config/napper-sync/
+  cli.py             the napper-sync command
+tools/               research scripts: analyse history, rediscover endpoints, round-trip and correction checks
+examples/            config, data files, systemd units, Windows task
+docs/                what is known about both APIs, and how to deploy
+tests/               pytest suite against an in-process mock of the Napper API
+```
+
+## Documentation
+
+- [docs/napper-api.md](https://github.com/PW-CODING/napper-sync/blob/main/docs/napper-api.md) - endpoints, auth, the log object,
+  all categories and fields, the traps (seconds in a field called minutes,
+  percent-encoded comments, date-based IDs), and how the write path was found
+- [docs/famly-api.md](https://github.com/PW-CODING/napper-sync/blob/main/docs/famly-api.md) - instances, token, the calendar
+  endpoint and its event shapes
+- [docs/deployment.md](https://github.com/PW-CODING/napper-sync/blob/main/docs/deployment.md) - systemd timer, hardening, Discord
+
+## Development
+
+```bash
+git clone https://github.com/PW-CODING/napper-sync && cd napper-sync
+pip install -e ".[dev]"
+pytest
+ruff check . && ruff format --check .
+```
+
+The tests run against an in-process HTTP mock that reproduces the real API's
+quirks (whole-day responses on write, 429 throttling, token refresh). Nothing
+touches a real account.
+
+Tools under `tools/` do talk to the real API and are meant for the day an app
+update breaks something: `probe_write_path.py` rediscovers the write endpoint,
+`roundtrip_categories.py` writes one entry per category far in the past,
+checks it and deletes it again, `analyze_categories.py` summarises which
+fields your own history actually uses, and `probe_corrections.py` checks that
+a correction made later at the nursery updates the Napper entry in place.
+
+## Contributing
+
+Issues and pull requests are welcome, in English or German. If an app update
+changed something, the most useful report includes the output of
+`tools/roundtrip_categories.py` or of `napper-sync famly calendar` for a day
+with the new event type (with names and IDs removed).
+
+## Related projects
+
+Community projects around the same two apps, none of which connects them:
+
+- [home-assistant-napper](https://github.com/g-nogueira/home-assistant-napper) -
+  read-only Napper integration for Home Assistant
+- [ha-napper](https://github.com/bbruenings/ha-napper) - another Home Assistant
+  integration for Napper
+- [napper-export](https://github.com/brittraee/napper-export) - export a child's
+  complete Napper history
+- [famly-fetch](https://github.com/jacobbunk/famly-fetch) - download your child's
+  photos from Famly
+
+## Acknowledgements
+
+Reading the Napper API was first worked out by
+[brittraee/napper-export](https://github.com/brittraee/napper-export) and
+[g-nogueira/home-assistant-napper](https://github.com/g-nogueira/home-assistant-napper);
+the OTP login flow and request headers here follow their findings. Writing,
+deleting, the category model and the Famly side were worked out for this
+project.
+
+## License
+
+[MIT](https://github.com/PW-CODING/napper-sync/blob/main/LICENSE)

napper_sync-0.1.0.dist-info/RECORD

@@ -0,0 +1,16 @@
+napper_sync/__init__.py,sha256=p4QuIcEqNeFAMc4Yb-8bCwzw1AjuPzKk4KEjGP2GSMM,321
+napper_sync/categories.py,sha256=MscrtWzo-icDp6IcX-6q5kKxwQltXTteCkrMo4rUg-g,10475
+napper_sync/cli.py,sha256=0pXfpurft67nlW60RCbMaJR2FxAgm1dWCXUyEXdhSBg,14051
+napper_sync/config.py,sha256=bO2Y0WLDZNHIMQiwDPEY499i8WARsth30cvKinAhRTw,4428
+napper_sync/famly.py,sha256=8qAnNhpUO1wMagX64zOG2iRRQAlFAMpe6IIk4eOys7U,6028
+napper_sync/famly_mapping.py,sha256=3R8hNC3RjWMFjF6VNs8zuL44wFBa0KinZC-rOKuYp4E,4737
+napper_sync/napper.py,sha256=J11pllwpA5mP5sjoTj_g1DQR9kqAGDQmn_fLsFhpbq0,15773
+napper_sync/notify.py,sha256=hRwWXd5lwzykyUSYccVvlcVKa6bTYullsR9uGp1cCH8,2967
+napper_sync/sources.py,sha256=oSOXdPCvb7X--W48DEkjsYSTJsn7V-BTq92-2PZZEu8,2788
+napper_sync/sync.py,sha256=o5z0bdB4D0kbXdRwZCoRsvuYy3USYEe3e9biQLYFl_8,9589
+napper_sync-0.1.0.dist-info/licenses/LICENSE,sha256=lg52NHZw6W30oWQk2f5ZTJMiD1kHIFFMa7ZyyiWN2Xs,1074
+napper_sync-0.1.0.dist-info/METADATA,sha256=58GDnUVV5CMbmLoSNLEtTwqrDaeBzMix1Q72JDFaBz4,10581
+napper_sync-0.1.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+napper_sync-0.1.0.dist-info/entry_points.txt,sha256=C0uhMS3uYy0RMNUBudm4q_KjfTWHSN7cMk_3Xd1Qf3o,53
+napper_sync-0.1.0.dist-info/top_level.txt,sha256=Xn-gotaBF0sE_DZjeaWs9hQGgW_T6Z24K-rmwkOqq6o,12
+napper_sync-0.1.0.dist-info/RECORD,,

napper_sync-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.2.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

napper_sync-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+napper-sync = napper_sync.cli:main

napper_sync-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Patrick Wuestling
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

napper_sync-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+napper_sync