bearkit 1.6.0__py3-none-any.whl

bearkit/__init__.py

@@ -0,0 +1,54 @@
+"""bearkit: the fundamentals for interacting with the Bear notes app.
+
+- `Bear`: the facade and recommended entry point - read notes, write them
+  through the Bear app (verified), all from one object.
+- `db` / `BearDB`: the raw read-only database layer (strictly read-only).
+- `actions`: Bear's x-callback-url write API (fire-and-forget URLs).
+- `ops`: verified write operations - fire an action, confirm it via the
+  database, return the fresh note, or raise `BearWriteError`.
+- `search`: naive and fuzzy search over notes.
+- `secrets`: offline secret detection and redaction for note text.
+- `markdown`: Bear markdown conventions (attachment links, tag markers).
+
+Nothing in this package depends on a UI; bearcli's CLI and TUI are built
+on top of it. macOS only (Bear is a macOS/iOS app).
+"""
+
+from bearkit import actions, db, markdown, ops, search, secrets
+from bearkit.bear import Bear
+from bearkit.db import (
+    DEFAULT_DB_PATH,
+    AmbiguousNoteId,
+    Attachment,
+    BearDB,
+    Note,
+    NoteFilter,
+)
+from bearkit.ops import BearWriteError, TagMarkerNotFound, TextMode
+from bearkit.search import SearchResult, naive_search, search_notes
+from bearkit.secrets import ScanReport, SecretFinding, scan_notes
+
+__all__ = [
+    "DEFAULT_DB_PATH",
+    "AmbiguousNoteId",
+    "Attachment",
+    "Bear",
+    "BearDB",
+    "BearWriteError",
+    "Note",
+    "NoteFilter",
+    "ScanReport",
+    "SearchResult",
+    "SecretFinding",
+    "TagMarkerNotFound",
+    "TextMode",
+    "actions",
+    "db",
+    "markdown",
+    "naive_search",
+    "ops",
+    "scan_notes",
+    "search",
+    "search_notes",
+    "secrets",
+]

bearkit/actions.py

@@ -0,0 +1,71 @@
+"""Write actions via Bear's x-callback-url scheme.
+
+The database stays strictly read-only; all mutations go through Bear's own
+URL API (which launches the app if needed). Calls are fire-and-forget — Bear
+gives no result back — so callers verify outcomes by re-reading the database.
+"""
+
+from __future__ import annotations
+
+import subprocess
+import time
+from collections.abc import Callable
+from urllib.parse import quote, urlencode
+
+BASE_URL = "bear://x-callback-url/"
+
+
+def call_bear(action: str, foreground: bool = False, **params: str | None) -> None:
+    query = urlencode({k: v for k, v in params.items() if v is not None}, quote_via=quote)
+    # -g keeps Bear in the background instead of stealing focus.
+    cmd = ["open", f"{BASE_URL}{action}?{query}"] if foreground else ["open", "-g", f"{BASE_URL}{action}?{query}"]
+    subprocess.run(cmd, check=True)
+
+
+def create_note(title: str, text: str | None = None, tags: list[str] | None = None) -> None:
+    call_bear(
+        "create",
+        title=title,
+        text=text,
+        tags=",".join(tags) if tags else None,
+        open_note="no",
+        show_window="no",
+    )
+
+
+def add_text(note_id: str, text: str, mode: str = "append") -> None:
+    call_bear("add-text", id=note_id, text=text, mode=mode, open_note="no", show_window="no")
+
+
+def add_file(note_id: str, filename: str, file_b64: str) -> None:
+    call_bear("add-file", id=note_id, filename=filename, file=file_b64, mode="append", open_note="no", show_window="no")
+
+
+def rename_tag(name: str, new_name: str) -> None:
+    call_bear("rename-tag", name=name, new_name=new_name, show_window="no")
+
+
+def delete_tag(name: str) -> None:
+    call_bear("delete-tag", name=name, show_window="no")
+
+
+def open_note(note_id: str, new_window: bool = False) -> None:
+    call_bear("open-note", foreground=True, id=note_id, new_window="yes" if new_window else "no")
+
+
+def trash_note(note_id: str) -> None:
+    call_bear("trash", id=note_id, show_window="no")
+
+
+def archive_note(note_id: str) -> None:
+    call_bear("archive", id=note_id, show_window="no")
+
+
+def wait_for(predicate: Callable[[], bool], timeout: float = 6.0, interval: float = 0.3) -> bool:
+    """Poll until predicate() is true; Bear applies URL actions asynchronously."""
+    deadline = time.monotonic() + timeout
+    while time.monotonic() < deadline:
+        if predicate():
+            return True
+        time.sleep(interval)
+    return predicate()

bearkit/bear.py

@@ -0,0 +1,159 @@
+"""The Bear facade: one object for reading and (verified) writing.
+
+The recommended entry point for library users. Reads go straight to the
+read-only database; writes go through Bear's x-callback API and are
+verified against the database before returning (raising `BearWriteError`
+if Bear never applies the change). The raw layers remain available as
+`bear.db`, `bearkit.ops`, and `bearkit.actions`.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+from datetime import datetime
+from pathlib import Path
+from types import TracebackType
+
+from bearkit import actions, ops
+from bearkit.db import DEFAULT_DB_PATH, BearDB, Note, NoteFilter
+from bearkit.ops import TextMode
+from bearkit.search import SearchResult, naive_search, search_notes
+from bearkit.secrets import ScanReport, scan_notes
+
+
+class Bear:
+    """A Bear library: read notes, and write them through the Bear app."""
+
+    def __init__(self, path: Path = DEFAULT_DB_PATH):
+        self.db = BearDB(path)
+
+    def close(self) -> None:
+        self.db.close()
+
+    def __enter__(self) -> Bear:
+        return self
+
+    def __exit__(
+        self, exc_type: type[BaseException] | None, exc: BaseException | None, tb: TracebackType | None
+    ) -> None:
+        self.close()
+
+    # ── reading ──────────────────────────────────────────────────────────
+
+    def list_notes(
+        self,
+        limit: int | None = None,
+        tag: str | None = None,
+        created_after: datetime | None = None,
+        created_before: datetime | None = None,
+        modified_after: datetime | None = None,
+        modified_before: datetime | None = None,
+        only: NoteFilter | str | None = None,
+        include_trashed: bool = False,
+        include_archived: bool = False,
+    ) -> list[Note]:
+        """Notes, most recently modified first (see BearDB.list_notes)."""
+        return self.db.list_notes(
+            limit=limit,
+            tag=tag,
+            created_after=created_after,
+            created_before=created_before,
+            modified_after=modified_after,
+            modified_before=modified_before,
+            only=only,
+            include_trashed=include_trashed,
+            include_archived=include_archived,
+        )
+
+    def get_note(self, note_id: str) -> Note | None:
+        """Fetch a note by id or unique 4+ char prefix; None when absent."""
+        return self.db.get_note(note_id)
+
+    def list_tags(self, include_empty: bool = False) -> list[tuple[str, int]]:
+        """All tags with their note counts."""
+        return self.db.list_tags(include_empty=include_empty)
+
+    def attachment_stats(self) -> tuple[int, int]:
+        """(count, total bytes) of attachments on non-trashed notes."""
+        return self.db.attachment_stats()
+
+    def search(
+        self,
+        query: str,
+        fuzzy: bool = False,
+        min_score: float = 60.0,
+        tag: str | Sequence[str] | None = None,
+        include_trashed: bool = False,
+        include_archived: bool = False,
+    ) -> list[SearchResult]:
+        """Search titles, tags, and content; fuzzy is typo-tolerant and ranked.
+
+        `tag` scopes the search to one tag or any of several (each including
+        its nested sub-tags, e.g. "work" also covers "work/ideas").
+        """
+        single = tag if isinstance(tag, str) else None
+        notes = self.list_notes(
+            limit=None, tag=single, include_trashed=include_trashed, include_archived=include_archived
+        )
+        if tag and not isinstance(tag, str):
+            wanted = [t.lower() for t in tag]
+            notes = [
+                n
+                for n in notes
+                if any(nt == w or nt.startswith(w + "/") for nt in (t.lower() for t in n.tags) for w in wanted)
+            ]
+        if fuzzy:
+            return search_notes(notes, query, min_score=min_score)
+        return naive_search(notes, query)
+
+    def scan_secrets(self, notes: list[Note] | None = None) -> ScanReport:
+        """Scan for secrets; defaults to every note, archived included."""
+        return scan_notes(notes if notes is not None else self.list_notes(limit=None, include_archived=True))
+
+    # ── verified writing ─────────────────────────────────────────────────
+
+    def create_note(self, title: str, text: str | None = None, tags: list[str] | None = None) -> Note:
+        """Create a note and return it once it appears in the database."""
+        return ops.create_note(self.db, title, text, tags)
+
+    def add_text(self, note: Note, text: str, mode: TextMode | str = TextMode.APPEND) -> Note:
+        """Append/prepend/replace note text."""
+        return ops.add_text(self.db, note, text, mode)
+
+    def rename(self, note: Note, new_title: str) -> Note:
+        """Replace the heading line, keeping the body."""
+        return ops.rename(self.db, note, new_title)
+
+    def add_tag(self, note: Note, name: str) -> Note:
+        """Add an inline tag marker to the note."""
+        return ops.add_tag(self.db, note, name)
+
+    def remove_tag(self, note: Note, name: str) -> Note:
+        """Remove the tag's inline marker; raises TagMarkerNotFound if absent."""
+        return ops.remove_tag(self.db, note, name)
+
+    def attach_file(self, note: Note, filename: str, file_b64: str) -> Note:
+        """Attach a base64-encoded file (keep it under ~500 KB)."""
+        return ops.attach_file(self.db, note, filename, file_b64)
+
+    def trash(self, note: Note) -> Note:
+        """Move the note to Bear's trash (one-way: no untrash API)."""
+        return ops.trash(self.db, note)
+
+    def archive(self, note: Note) -> Note:
+        """Archive the note (one-way: no unarchive API)."""
+        return ops.archive(self.db, note)
+
+    def rename_tag(self, name: str, new_name: str) -> None:
+        """Rename a tag across all notes."""
+        ops.rename_tag(self.db, name, new_name)
+
+    def delete_tag(self, name: str) -> None:
+        """Delete a tag from every note that has it."""
+        ops.delete_tag(self.db, name)
+
+    # ── the Bear app ─────────────────────────────────────────────────────
+
+    def open(self, note: Note, new_window: bool = False) -> None:
+        """Bring the note up in the Bear app."""
+        actions.open_note(note.id, new_window=new_window)

bearkit/db.py

@@ -0,0 +1,343 @@
+"""Read-only access to Bear's SQLite database."""
+
+from __future__ import annotations
+
+import re
+import sqlite3
+from dataclasses import dataclass, field
+from datetime import UTC, datetime, timedelta
+from enum import StrEnum
+from pathlib import Path
+from types import TracebackType
+
+DEFAULT_DB_PATH = (
+    Path.home() / "Library/Group Containers/9K33E3U3T4.net.shinyfrog.bear" / "Application Data/database.sqlite"
+)
+
+# Core Data stores timestamps as seconds since 2001-01-01 UTC.
+CORE_DATA_EPOCH = datetime(2001, 1, 1, tzinfo=UTC)
+
+
+def core_data_to_datetime(value: float | None) -> datetime | None:
+    if value is None:
+        return None
+    return (CORE_DATA_EPOCH + timedelta(seconds=value)).astimezone()
+
+
+def datetime_to_core_data(value: datetime) -> float:
+    if value.tzinfo is None:
+        value = value.astimezone()
+    return (value - CORE_DATA_EPOCH).total_seconds()
+
+
+class NoteFilter(StrEnum):
+    """Restrict a listing to notes carrying exactly this status."""
+
+    PINNED = "pinned"
+    ENCRYPTED = "encrypted"
+    TRASHED = "trashed"
+    ARCHIVED = "archived"
+
+
+@dataclass
+class Attachment:
+    id: str
+    filename: str
+    path: Path
+    size: int | None
+    exists: bool
+
+
+@dataclass
+class Note:
+    id: str
+    title: str
+    created: datetime | None
+    modified: datetime | None
+    pinned: bool
+    encrypted: bool
+    archived: bool
+    trashed: bool
+    tags: list[str] = field(default_factory=list)
+    text: str | None = None
+    """The full markdown content; None if and only if the note is encrypted."""
+    attachments: list[Attachment] = field(default_factory=list)
+
+    def has_tag(self, name: str) -> bool:
+        """Whether the note carries the tag (case-insensitive, exact name)."""
+        return name.lower() in (t.lower() for t in self.tags)
+
+    def to_dict(self) -> dict:
+        """Serializable metadata: id, title, tags, ISO dates, status flags."""
+        return {
+            "id": self.id,
+            "title": self.title,
+            "tags": self.tags,
+            "created": self.created.isoformat() if self.created else None,
+            "modified": self.modified.isoformat() if self.modified else None,
+            "pinned": self.pinned,
+            "encrypted": self.encrypted,
+            "archived": self.archived,
+            "trashed": self.trashed,
+        }
+
+    @property
+    def status_line(self) -> str:
+        """Comma-joined status flags for display, e.g. "pinned,archived"."""
+        flags = (
+            ("pinned", self.pinned),
+            ("encrypted", self.encrypted),
+            ("trashed", self.trashed),
+            ("archived", self.archived),
+        )
+        return ",".join(name for name, on in flags if on)
+
+
+class AmbiguousNoteId(Exception):
+    """A note id prefix matched more than one note."""
+
+    def __init__(self, prefix: str, matches: list[tuple[str, str]]):
+        super().__init__(f"note id prefix {prefix!r} is ambiguous")
+        self.prefix = prefix
+        self.matches = matches  # (id, title) pairs
+
+
+MIN_ID_PREFIX = 4
+
+
+class BearDB:
+    def __init__(self, path: Path = DEFAULT_DB_PATH):
+        if not path.exists():
+            raise FileNotFoundError(f"Bear database not found at {path}")
+        self.conn = sqlite3.connect(f"file:{path}?mode=ro", uri=True)
+        self.conn.row_factory = sqlite3.Row
+        self.files_dir = path.parent / "Local Files"
+        self._tags_join = self._detect_tags_join()
+
+    def close(self) -> None:
+        self.conn.close()
+
+    def __enter__(self) -> BearDB:
+        return self
+
+    def __exit__(
+        self, exc_type: type[BaseException] | None, exc: BaseException | None, tb: TracebackType | None
+    ) -> None:
+        self.close()
+
+    def _detect_tags_join(self) -> tuple[str, str, str]:
+        """Find the note<->tag join table; its numeric prefixes vary by Bear version.
+
+        Returns (table, note_column, tag_column).
+        """
+        rows = self.conn.execute(
+            "SELECT name FROM sqlite_master WHERE type = 'table' AND name LIKE 'Z\\_%TAGS' ESCAPE '\\'"
+        ).fetchall()
+        for (table,) in rows:
+            if not re.fullmatch(r"Z_\d+TAGS", table):
+                continue
+            columns = [r["name"] for r in self.conn.execute(f"PRAGMA table_info({table})")]
+            note_col = next((c for c in columns if re.fullmatch(r"Z_\d+NOTES", c)), None)
+            tag_col = next((c for c in columns if re.fullmatch(r"Z_\d+TAGS", c)), None)
+            if note_col and tag_col:
+                return table, note_col, tag_col
+        raise RuntimeError("Could not locate the note/tag join table in the Bear database")
+
+    def _tags_for_note(self, note_pk: int) -> list[str]:
+        table, note_col, tag_col = self._tags_join
+        rows = self.conn.execute(
+            f"""
+            SELECT t.ZTITLE FROM ZSFNOTETAG t
+            JOIN {table} j ON j.{tag_col} = t.Z_PK
+            WHERE j.{note_col} = ?
+            ORDER BY t.ZTITLE
+            """,
+            (note_pk,),
+        ).fetchall()
+        return [r["ZTITLE"] for r in rows]
+
+    def list_tags(self, include_empty: bool = False) -> list[tuple[str, int]]:
+        """All tags with their note counts (excluding trashed/deleted notes).
+
+        Bear keeps tag rows around after their last note is untagged (the app
+        hides them), so empty tags are excluded unless include_empty is set.
+        """
+        table, note_col, tag_col = self._tags_join
+        having = "" if include_empty else "HAVING COUNT(n.Z_PK) > 0"
+        rows = self.conn.execute(
+            f"""
+            SELECT t.ZTITLE, COUNT(n.Z_PK)
+            FROM ZSFNOTETAG t
+            LEFT JOIN {table} j ON j.{tag_col} = t.Z_PK
+            LEFT JOIN ZSFNOTE n
+                ON n.Z_PK = j.{note_col} AND n.ZTRASHED = 0 AND n.ZPERMANENTLYDELETED = 0
+            GROUP BY t.Z_PK
+            {having}
+            ORDER BY t.ZTITLE
+            """
+        ).fetchall()
+        return [(row[0], row[1]) for row in rows]
+
+    def attachment_stats(self) -> tuple[int, int]:
+        """(count, total bytes) of attachments on non-deleted notes."""
+        row = self.conn.execute(
+            """
+            SELECT COUNT(*), COALESCE(SUM(f.ZFILESIZE), 0)
+            FROM ZSFNOTEFILE f
+            JOIN ZSFNOTE n ON n.Z_PK = f.ZNOTE
+            WHERE f.ZPERMANENTLYDELETED = 0 AND n.ZPERMANENTLYDELETED = 0 AND n.ZTRASHED = 0
+            """
+        ).fetchone()
+        return row[0], row[1]
+
+    def _attachments_for_note(self, note_pk: int) -> list[Attachment]:
+        rows = self.conn.execute(
+            """
+            SELECT ZUNIQUEIDENTIFIER, ZFILENAME, ZFILESIZE FROM ZSFNOTEFILE
+            WHERE ZNOTE = ? AND ZPERMANENTLYDELETED = 0 ORDER BY ZFILENAME
+            """,
+            (note_pk,),
+        ).fetchall()
+        attachments = []
+        for row in rows:
+            # Images live under "Note Images", everything else under "Note Files";
+            # the database doesn't record which, so probe both.
+            candidates = [
+                self.files_dir / subdir / row["ZUNIQUEIDENTIFIER"] / row["ZFILENAME"]
+                for subdir in ("Note Images", "Note Files")
+            ]
+            path = next((c for c in candidates if c.exists()), candidates[0])
+            attachments.append(
+                Attachment(
+                    id=row["ZUNIQUEIDENTIFIER"],
+                    filename=row["ZFILENAME"],
+                    path=path,
+                    size=row["ZFILESIZE"],
+                    exists=path.exists(),
+                )
+            )
+        return attachments
+
+    def list_notes(
+        self,
+        limit: int | None = None,
+        tag: str | None = None,
+        created_after: datetime | None = None,
+        created_before: datetime | None = None,
+        modified_after: datetime | None = None,
+        modified_before: datetime | None = None,
+        only: NoteFilter | str | None = None,
+        include_trashed: bool = False,
+        include_archived: bool = False,
+    ) -> list[Note]:
+        """Notes, most recently modified first.
+
+        Trashed and archived notes are excluded unless included explicitly or
+        selected via `only`; permanently-deleted rows never appear.
+        """
+        only = NoteFilter(only) if only is not None else None
+        table, note_col, tag_col = self._tags_join
+        # Deleted-pending-sync rows linger in the table; never show them.
+        where = ["n.ZPERMANENTLYDELETED = 0"]
+        params: list[object] = []
+
+        if only is NoteFilter.PINNED:
+            where.append("n.ZPINNED = 1")
+        elif only is NoteFilter.ENCRYPTED:
+            where.append("n.ZENCRYPTED = 1")
+
+        if only is NoteFilter.TRASHED:
+            where.append("n.ZTRASHED = 1")
+        elif not include_trashed:
+            where.append("n.ZTRASHED = 0")
+        if only is NoteFilter.ARCHIVED:
+            where.append("n.ZARCHIVED = 1")
+        elif not include_archived and only is not NoteFilter.TRASHED:
+            # A note trashed from the archive keeps both flags; Bear shows it in
+            # the trash, so --only trashed must not exclude archived notes.
+            where.append("n.ZARCHIVED = 0")
+        if tag:
+            # Match the tag itself and its nested sub-tags (e.g. "work" matches "work/ideas").
+            where.append(
+                f"""n.Z_PK IN (
+                    SELECT j.{note_col} FROM {table} j
+                    JOIN ZSFNOTETAG t ON t.Z_PK = j.{tag_col}
+                    WHERE t.ZTITLE = ? OR t.ZTITLE LIKE ? ESCAPE '\\'
+                )"""
+            )
+            escaped = tag.replace("\\", "\\\\").replace("%", "\\%").replace("_", "\\_")
+            params += [tag, f"{escaped}/%"]
+        if created_after:
+            where.append("n.ZCREATIONDATE >= ?")
+            params.append(datetime_to_core_data(created_after))
+        if created_before:
+            where.append("n.ZCREATIONDATE < ?")
+            params.append(datetime_to_core_data(created_before))
+        if modified_after:
+            where.append("n.ZMODIFICATIONDATE >= ?")
+            params.append(datetime_to_core_data(modified_after))
+        if modified_before:
+            where.append("n.ZMODIFICATIONDATE < ?")
+            params.append(datetime_to_core_data(modified_before))
+
+        query = """
+            SELECT n.Z_PK, n.ZUNIQUEIDENTIFIER, n.ZTITLE, n.ZCREATIONDATE,
+                   n.ZMODIFICATIONDATE, n.ZPINNED, n.ZENCRYPTED, n.ZARCHIVED, n.ZTRASHED, n.ZTEXT
+            FROM ZSFNOTE n
+        """
+        if where:
+            query += " WHERE " + " AND ".join(where)
+        query += " ORDER BY n.ZMODIFICATIONDATE DESC"
+        if limit is not None:
+            query += " LIMIT ?"
+            params.append(limit)
+
+        return [self._note_from_row(row, text=row["ZTEXT"]) for row in self.conn.execute(query, params)]
+
+    def get_note(self, note_id: str) -> Note | None:
+        """Fetch a note by id; a unique prefix (>= 4 chars) works like a full id."""
+        row = self.conn.execute(
+            """
+            SELECT Z_PK, ZUNIQUEIDENTIFIER, ZTITLE, ZTEXT, ZCREATIONDATE,
+                   ZMODIFICATIONDATE, ZPINNED, ZENCRYPTED, ZARCHIVED, ZTRASHED
+            FROM ZSFNOTE
+            WHERE ZUNIQUEIDENTIFIER = ? COLLATE NOCASE
+            """,
+            (note_id,),
+        ).fetchone()
+        if row is None and len(note_id) >= MIN_ID_PREFIX:
+            escaped = note_id.replace("\\", "\\\\").replace("%", "\\%").replace("_", "\\_")
+            matches = self.conn.execute(
+                """
+                SELECT Z_PK, ZUNIQUEIDENTIFIER, ZTITLE, ZTEXT, ZCREATIONDATE,
+                       ZMODIFICATIONDATE, ZPINNED, ZENCRYPTED, ZARCHIVED, ZTRASHED
+                FROM ZSFNOTE
+                WHERE ZUNIQUEIDENTIFIER LIKE ? ESCAPE '\\' COLLATE NOCASE AND ZPERMANENTLYDELETED = 0
+                LIMIT 6
+                """,
+                (f"{escaped}%",),
+            ).fetchall()
+            if len(matches) > 1:
+                raise AmbiguousNoteId(note_id, [(r["ZUNIQUEIDENTIFIER"], r["ZTITLE"] or "(untitled)") for r in matches])
+            if matches:
+                row = matches[0]
+        if row is None:
+            return None
+        return self._note_from_row(row, text=row["ZTEXT"], attachments=self._attachments_for_note(row["Z_PK"]))
+
+    def _note_from_row(
+        self, row: sqlite3.Row, text: str | None = None, attachments: list[Attachment] | None = None
+    ) -> Note:
+        return Note(
+            id=row["ZUNIQUEIDENTIFIER"],
+            title=row["ZTITLE"] or "(untitled)",
+            created=core_data_to_datetime(row["ZCREATIONDATE"]),
+            modified=core_data_to_datetime(row["ZMODIFICATIONDATE"]),
+            pinned=bool(row["ZPINNED"]),
+            encrypted=bool(row["ZENCRYPTED"]),
+            archived=bool(row["ZARCHIVED"]),
+            trashed=bool(row["ZTRASHED"]),
+            tags=self._tags_for_note(row["Z_PK"]),
+            text=text,
+            attachments=attachments or [],
+        )

bearkit/markdown.py

@@ -0,0 +1,45 @@
+"""Helpers for Bear's markdown conventions, shared by the CLI, TUI, and export."""
+
+from __future__ import annotations
+
+import re
+from collections.abc import Callable
+from urllib.parse import quote
+
+from bearkit.db import Attachment, Note
+
+
+def rewrite_attachment_refs(note: Note, target_for: Callable[[Attachment], str]) -> str:
+    """Rewrite bare attachment filename links to per-attachment targets.
+
+    Bear references attachments by bare filename and percent-encodes it in the
+    note text (spaces as %20), so both the raw and encoded forms must be
+    matched; targets are emitted percent-encoded to keep the links valid.
+    Only filenames known from the attachment records are rewritten — regular
+    URLs in the text are never touched.
+    """
+    text = note.text or ""
+    for att in note.attachments:
+        target = quote(target_for(att))
+        for ref in {att.filename, quote(att.filename)}:
+            text = text.replace(f"]({ref})", f"]({target})")
+    return text
+
+
+def tag_marker(name: str) -> str:
+    """The inline marker Bear uses for a tag: #name, or #name# when it needs delimiting."""
+    return f"#{name}#" if re.search(r"[^\w/-]", name) else f"#{name}"
+
+
+def remove_tag_marker(text: str, name: str) -> str | None:
+    """The text with the tag's inline markers stripped, or None if none matched.
+
+    Longer tags sharing the prefix are left alone: removing "work" must not
+    touch "#work/ideas" or "#workout".
+    """
+    escaped = re.escape(name)
+    stripped = re.sub(rf"[ \t]?#{escaped}#", "", text, flags=re.IGNORECASE)
+    stripped = re.sub(rf"[ \t]?#{escaped}(?![\w/-])", "", stripped, flags=re.IGNORECASE)
+    if stripped == text:
+        return None
+    return stripped.rstrip("\n") + "\n"

bearkit/ops.py

@@ -0,0 +1,150 @@
+"""Verified write operations.
+
+Each function fires a Bear x-callback action, confirms the outcome by
+re-reading the database, and returns the fresh note. If Bear never
+observably applies the change within `VERIFY_TIMEOUT` seconds (typically:
+Bear cannot run), `BearWriteError` is raised.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from datetime import UTC, datetime, timedelta
+from enum import StrEnum
+
+from bearkit import actions
+from bearkit.db import BearDB, Note
+from bearkit.markdown import remove_tag_marker, tag_marker
+
+VERIFY_TIMEOUT = 6.0
+"""Seconds to wait for Bear to apply a write before raising BearWriteError."""
+
+
+class TextMode(StrEnum):
+    """Where `add_text` puts the text (mirrors Bear's add-text modes)."""
+
+    APPEND = "append"
+    PREPEND = "prepend"
+    REPLACE = "replace"  # replaces the body, keeps the title
+    REPLACE_ALL = "replace_all"  # replaces everything including the title
+
+
+class BearWriteError(RuntimeError):
+    """Bear did not observably apply the write (is Bear able to run?)."""
+
+
+class TagMarkerNotFound(LookupError):
+    """The note text contains no inline marker for the tag being removed."""
+
+
+def _confirmed(db: BearDB, note_id: str, operation: str, changed: Callable[[Note], bool]) -> Note:
+    def check() -> bool:
+        fresh = db.get_note(note_id)
+        return fresh is not None and changed(fresh)
+
+    if actions.wait_for(check, timeout=VERIFY_TIMEOUT):
+        fresh = db.get_note(note_id)
+        if fresh is not None:
+            return fresh
+    raise BearWriteError(f"{operation} was not applied to note {note_id}")
+
+
+def _modified_after(before: Note) -> Callable[[Note], bool]:
+    return lambda n: n.modified is not None and (before.modified is None or n.modified > before.modified)
+
+
+def create_note(db: BearDB, title: str, text: str | None, tags: list[str] | None = None) -> Note:
+    """Create a note through Bear and return it once it appears in the database."""
+    started = datetime.now(UTC)
+    actions.create_note(title, text=text, tags=tags)
+
+    def find() -> Note | None:
+        return next(
+            (
+                n
+                for n in db.list_notes(limit=10)
+                if n.title == title and n.created and n.created >= started - timedelta(seconds=5)
+            ),
+            None,
+        )
+
+    if actions.wait_for(lambda: find() is not None, timeout=VERIFY_TIMEOUT):
+        created = find()
+        if created is not None:
+            return created
+    raise BearWriteError(f"created note {title!r} did not appear in the database")
+
+
+def add_text(db: BearDB, note: Note, text: str, mode: TextMode | str = TextMode.APPEND) -> Note:
+    """Append/prepend/replace note text; verified by the modification date bump."""
+    actions.add_text(note.id, text, mode=TextMode(mode).value)
+    return _confirmed(db, note.id, "text change", _modified_after(note))
+
+
+def rename(db: BearDB, note: Note, new_title: str) -> Note:
+    """Replace the heading line, keeping the body."""
+    head, sep, body = (note.text or "").partition("\n")
+    if head.startswith("# "):
+        new_text = f"# {new_title}{sep}{body}"
+    else:
+        new_text = f"# {new_title}\n{note.text or ''}"
+    actions.add_text(note.id, new_text, mode=TextMode.REPLACE_ALL.value)
+    return _confirmed(db, note.id, "rename", lambda n: n.title == new_title)
+
+
+def add_tag(db: BearDB, note: Note, name: str) -> Note:
+    actions.add_text(note.id, tag_marker(name), mode=TextMode.APPEND.value)
+    return _confirmed(db, note.id, "tag", lambda n: n.has_tag(name))
+
+
+def remove_tag(db: BearDB, note: Note, name: str) -> Note:
+    """Rewrite the note without the tag marker.
+
+    Raises TagMarkerNotFound when the text has no marker for the tag.
+    """
+    new_text = remove_tag_marker(note.text or "", name)
+    if new_text is None:
+        raise TagMarkerNotFound(f"no #{name} marker in the note text")
+    actions.add_text(note.id, new_text, mode=TextMode.REPLACE_ALL.value)
+    return _confirmed(db, note.id, "untag", lambda n: not n.has_tag(name))
+
+
+def attach_file(db: BearDB, note: Note, filename: str, file_b64: str) -> Note:
+    before = len(note.attachments)
+    actions.add_file(note.id, filename, file_b64)
+    return _confirmed(db, note.id, "attach", lambda n: len(n.attachments) > before)
+
+
+def trash(db: BearDB, note: Note) -> Note:
+    actions.trash_note(note.id)
+    return _confirmed(db, note.id, "trash", lambda n: n.trashed)
+
+
+def archive(db: BearDB, note: Note) -> Note:
+    actions.archive_note(note.id)
+    return _confirmed(db, note.id, "archive", lambda n: n.archived)
+
+
+def rename_tag(db: BearDB, name: str, new_name: str) -> None:
+    """Rename a tag across all notes; verified via the tag list."""
+    actions.rename_tag(name, new_name)
+    if not actions.wait_for(
+        lambda: new_name.lower() in {t.lower() for t, _ in db.list_tags(include_empty=True)},
+        timeout=VERIFY_TIMEOUT,
+    ):
+        raise BearWriteError(f"tag {name!r} was not renamed")
+
+
+def delete_tag(db: BearDB, name: str) -> None:
+    """Delete a tag from every note; verified by its note count reaching zero.
+
+    Bear keeps the empty tag row behind, so absence is not the signal.
+    """
+    actions.delete_tag(name)
+
+    def gone() -> bool:
+        counts = {t.lower(): c for t, c in db.list_tags(include_empty=True)}
+        return counts.get(name.lower(), 0) == 0
+
+    if not actions.wait_for(gone, timeout=VERIFY_TIMEOUT):
+        raise BearWriteError(f"tag {name!r} was not deleted")

bearkit/search.py

@@ -0,0 +1,121 @@
+"""Fuzzy search over notes using rapidfuzz."""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+
+from rapidfuzz import fuzz, utils
+
+from bearkit.db import Note
+
+# Where the match landed determines its weight: a title hit beats an equally
+# good tag hit, which beats a body hit.
+TITLE_WEIGHT = 1.0
+TAG_WEIGHT = 0.95
+BODY_WEIGHT = 0.9
+
+SNIPPET_LENGTH = 70
+
+
+@dataclass
+class SearchResult:
+    note: Note
+    snippet: str
+    score: float | None = None  # None for naive (substring) matches
+
+
+def naive_search(notes: list[Note], query: str) -> list[SearchResult]:
+    """Case-insensitive substring search over titles, tags, and text.
+
+    Input order (most recently modified first) is preserved.
+    """
+    needle = query.lower()
+    results = []
+    for note in notes:
+        title_hit = needle in note.title.lower()
+        tag_hit = any(needle in tag.lower() for tag in note.tags)
+        body_line = next(
+            (line.strip() for line in (note.text or "").splitlines() if needle in line.lower()),
+            "",
+        )
+        if not (title_hit or tag_hit or body_line):
+            continue
+        snippet = _trim_snippet(body_line, query) if body_line and not (title_hit or tag_hit) else ""
+        results.append(SearchResult(note=note, snippet=snippet))
+    return results
+
+
+def _fuzzy_score(processed_query: str, target: str) -> float:
+    """Direction-aware scoring: the query must always be the needle.
+
+    partial_ratio slides the shorter string over the longer one, so a trivially
+    short target ("Bindi") would score ~80 against a long query. Only allow the
+    sliding when the target is at least query-sized; otherwise use plain ratio,
+    which penalizes the missing content.
+    """
+    processed_target = utils.default_process(target)
+    if not processed_query or not processed_target:
+        return 0.0
+    if len(processed_target) >= len(processed_query):
+        return fuzz.partial_ratio(processed_query, processed_target)
+    return fuzz.ratio(processed_query, processed_target)
+
+
+def _body_match(query: str, text: str | None) -> tuple[float, str]:
+    """Score the query against the full note text; return (score, matching line).
+
+    partial_ratio must slide the query over the text, never the reverse: with a
+    short haystack the needle/haystack roles flip and trivial strings score ~90.
+    """
+    processed_query = utils.default_process(query)
+    processed_text = utils.default_process(text or "")
+    if not processed_query or not processed_text:
+        return 0.0, ""
+    if len(processed_text) < len(processed_query):
+        return fuzz.ratio(processed_query, processed_text), (text or "").strip().splitlines()[0]
+
+    alignment = fuzz.partial_ratio_alignment(processed_query, processed_text)
+    if alignment is None:
+        return 0.0, ""
+    # default_process keeps positions 1:1 (non-alnum become spaces) except for
+    # the leading strip, so shift by where the first alphanumeric char was.
+    first_alnum = re.search(r"[^\W_]", text or "")
+    pos = alignment.dest_start + (first_alnum.start() if first_alnum else 0)
+    line_start = (text or "").rfind("\n", 0, pos) + 1
+    line_end = (text or "").find("\n", pos)
+    line = (text or "")[line_start : line_end if line_end >= 0 else None].strip()
+    return alignment.score, line
+
+
+def _trim_snippet(line: str, query: str) -> str:
+    if len(line) <= SNIPPET_LENGTH:
+        return line
+    # Center the snippet on the first query word that occurs literally, if any.
+    lowered = line.lower()
+    pos = next((p for w in query.lower().split() if (p := lowered.find(w)) >= 0), 0)
+    start = max(0, min(pos - SNIPPET_LENGTH // 3, len(line) - SNIPPET_LENGTH))
+    end = start + SNIPPET_LENGTH
+    prefix = "…" if start > 0 else ""
+    suffix = "…" if end < len(line) else ""
+    return f"{prefix}{line[start:end].strip()}{suffix}"
+
+
+def search_notes(notes: list[Note], query: str, min_score: float = 60.0) -> list[SearchResult]:
+    """Score every note against the query; return matches sorted best-first."""
+    processed_query = utils.default_process(query)
+    results = []
+    for note in notes:
+        title_score = _fuzzy_score(processed_query, note.title) * TITLE_WEIGHT
+        tag_score = max(_fuzzy_score(processed_query, tag) for tag in note.tags) * TAG_WEIGHT if note.tags else 0.0
+        body_raw, body_line = _body_match(query, note.text)
+        body_score = body_raw * BODY_WEIGHT
+
+        score = max(title_score, tag_score, body_score)
+        if score < min_score:
+            continue
+        snippet = _trim_snippet(body_line, query) if body_score >= max(title_score, tag_score) else ""
+        results.append(SearchResult(note=note, score=score, snippet=snippet))
+
+    results.sort(key=lambda r: r.score or 0.0, reverse=True)
+    return results

bearkit/secrets.py

@@ -0,0 +1,242 @@
+"""Secret detection over note text, powered by detect-secrets (Yelp) plus
+note-specific detectors.
+
+A first line of defense before notes leave the machine via export. Everything
+runs offline — note content is never sent anywhere. detect-secrets provides
+the format detectors (AWS, GitHub, Slack, Stripe, private keys, JWTs, keyword
+assignments, …); two gaps matter for prose notes and are covered here:
+
+- detect-secrets' entropy plugins only match *quoted* strings, which pasted
+  keys in notes never are — so unquoted token runs get their own entropy scan.
+- Credentials in notes often sit on the line *below* a label ("Client
+  secret:" then the value, often inside a code fence) — a look-ahead rule
+  catches those.
+
+Secrets written as prose are still undetectable; for deeper auditing run
+gitleaks over an --allow-secrets export.
+"""
+
+from __future__ import annotations
+
+import math
+import re
+from collections.abc import Iterator
+from dataclasses import dataclass
+
+from detect_secrets.core.plugins.util import get_mapping_from_secret_type_to_class
+from detect_secrets.filters import heuristic
+from detect_secrets.plugins.base import BasePlugin
+
+from bearkit.db import Note
+
+# IPPublicDetector: an IP address in a note is not a credential.
+# The entropy plugins only match quoted strings — replaced by _scan_entropy.
+_EXCLUDED_PLUGINS = {"IPPublicDetector", "Base64HighEntropyString", "HexHighEntropyString"}
+
+_BASE64_ENTROPY_LIMIT = 4.5  # detect-secrets' default
+_HEX_ENTROPY_LIMIT = 3.5  # above default (3.0): notes are full of UUID/hash fragments
+
+# A contiguous credential-looking run: base64/urlsafe chars plus the '.' that
+# joins JWT segments. 20+ chars keeps ordinary words and short ids out.
+_TOKEN_RUN = re.compile(r"[A-Za-z0-9+/\-_=.]{20,}")
+_HEX_ONLY = re.compile(r"^[0-9a-fA-F]+$")
+
+# "Client secret:" / "Access token" style label with nothing after it — the
+# value is expected on the next content line (code fences skipped).
+_LABEL_ONLY = re.compile(
+    r"(?i)^\s*\**(?:client\s+secret|secret\s+access\s+key|access\s+token|auth\s+token|refresh\s+token"
+    r"|api\s*-?\s*key|access\s+key|private\s+key|secret|password|passwd|pwd|token)\s*\**\s*[:=]?\s*$"
+)
+_FENCE = re.compile(r"^\s*(?:```|~~~)")
+_TRIM_PUNCT = "()[]{}<>«»\"'`,;|"
+
+
+def _build_plugins() -> list[BasePlugin]:
+    return [cls() for cls in get_mapping_from_secret_type_to_class().values() if cls.__name__ not in _EXCLUDED_PLUGINS]
+
+
+def _entropy(value: str) -> float:
+    counts = {char: value.count(char) for char in set(value)}
+    return -sum(n / len(value) * math.log2(n / len(value)) for n in counts.values())
+
+
+def _is_false_positive(value: str, line: str) -> bool:
+    return (
+        heuristic.is_potential_uuid(value)
+        or heuristic.is_sequential_string(value)
+        or heuristic.is_templated_secret(value)
+        or heuristic.is_likely_id_string(value, line)
+        or heuristic.is_not_alphanumeric_string(value)
+    )
+
+
+def _expand_to_token(line: str, value: str) -> str:
+    """Grow a detected value to the full unbroken token around it.
+
+    Format detectors can match only part of a longer credential (a JWT's
+    first two segments, say); redacting the partial match would leave the
+    rest behind.
+    """
+    start = line.find(value)
+    if start < 0:
+        return value
+    end = start + len(value)
+    while start > 0 and not line[start - 1].isspace():
+        start -= 1
+    while end < len(line) and not line[end].isspace():
+        end += 1
+    return line[start:end].strip(_TRIM_PUNCT)
+
+
+def _in_url(line: str, start: int) -> bool:
+    """Whether the token starting at `start` is part of a URL.
+
+    Long ids inside links (Google Docs, Notion, …) are high-entropy but are
+    shareable references, not credentials — flagging them would drown real
+    findings. Token-bearing URLs with known formats (Slack webhooks, …) are
+    still caught by their format detectors.
+    """
+    token_start = start
+    while token_start > 0 and not line[token_start - 1].isspace():
+        token_start -= 1
+    return "://" in line[token_start : start + 3]
+
+
+def _scan_entropy(line: str) -> list[str]:
+    hits = []
+    for match in _TOKEN_RUN.finditer(line):
+        if _in_url(line, match.start()):
+            continue
+        value = match.group().strip(_TRIM_PUNCT + ".=")
+        limit = _HEX_ENTROPY_LIMIT if _HEX_ONLY.fullmatch(value) else _BASE64_ENTROPY_LIMIT
+        if len(value) >= 20 and _entropy(value) >= limit:
+            hits.append(match.group())
+    return hits
+
+
+def _labeled_value(lines: list[str], label_index: int) -> tuple[int, str] | None:
+    """The first content line after a bare credential label, if it looks like a value."""
+    for offset in range(1, 4):
+        index = label_index + offset
+        if index >= len(lines):
+            return None
+        candidate = lines[index].strip()
+        if not candidate or _FENCE.match(candidate):
+            continue
+        candidate = candidate.strip(_TRIM_PUNCT)
+        if " " not in candidate and 8 <= len(candidate) <= 200:
+            return index, candidate
+        return None
+    return None
+
+
+@dataclass
+class SecretFinding:
+    note_id: str
+    note_title: str
+    rule: str
+    line: int
+    excerpt: str
+    secret: str  # raw value, for redaction only — never print this
+
+
+def _redact(value: str) -> str:
+    """Show enough to locate the secret in the note, never the secret itself."""
+    return f"{value[:8]}…" if len(value) > 12 else "…"
+
+
+def _scan_note(note: Note, plugins: list[BasePlugin]) -> list[SecretFinding]:
+    lines = list((note.text or "").splitlines())
+    seen: set[str] = set()
+    findings: list[SecretFinding] = []
+
+    def add(lineno: int, value: str, rule: str) -> None:
+        if value and value not in seen and not _is_false_positive(value, lines[lineno - 1]):
+            seen.add(value)
+            findings.append(
+                SecretFinding(
+                    note_id=note.id,
+                    note_title=note.title,
+                    rule=rule,
+                    line=lineno,
+                    excerpt=_redact(value),
+                    secret=value,
+                )
+            )
+
+    for lineno, line in enumerate(lines, start=1):
+        for plugin in plugins:
+            # The yaml filetype hint makes KeywordDetector accept unquoted
+            # `password: value` assignments, which is how notes write them.
+            for secret in plugin.analyze_line(filename="note.yaml", line=line, line_number=lineno):
+                add(lineno, _expand_to_token(line, secret.secret_value or ""), secret.type)
+        for value in _scan_entropy(line):
+            add(lineno, value, "High Entropy String")
+        if _LABEL_ONLY.match(line):
+            if labeled := _labeled_value(lines, lineno - 1):
+                value_index, value = labeled
+                add(value_index + 1, value, "Labeled Credential")
+    return findings
+
+
+def _replace(text: str, secrets: dict[str, str]) -> str:
+    # Longest first, in case one detected value contains another.
+    for value in sorted(secrets, key=len, reverse=True):
+        text = text.replace(value, f"[redacted: {secrets[value]}]")
+    return text
+
+
+@dataclass
+class ScanReport:
+    """The outcome of a scan: findings, plus the redaction that follows.
+
+    Iterable and truthy on findings; per-note access via `has`/`for_note`;
+    `redact`/`redact_text` replace each detected value with a
+    `[redacted: <rule>]` placeholder.
+    """
+
+    findings: list[SecretFinding]
+
+    def __iter__(self) -> Iterator[SecretFinding]:
+        return iter(self.findings)
+
+    def __len__(self) -> int:
+        return len(self.findings)
+
+    def __bool__(self) -> bool:
+        return bool(self.findings)
+
+    def has(self, note_id: str) -> bool:
+        return any(f.note_id == note_id for f in self.findings)
+
+    def for_note(self, note_id: str) -> dict[str, str]:
+        """The note's secret values mapped to the rule that found them."""
+        values: dict[str, str] = {}
+        for finding in self.findings:
+            if finding.note_id == note_id and finding.secret:
+                values.setdefault(finding.secret, finding.rule)
+        return values
+
+    def redact_text(self, text: str) -> str:
+        """The text with every detected value replaced by its placeholder."""
+        secrets: dict[str, str] = {}
+        for finding in self.findings:
+            if finding.secret:
+                secrets.setdefault(finding.secret, finding.rule)
+        return _replace(text, secrets)
+
+    def redact(self, note: Note) -> str:
+        """The note's text, redacted ("" for encrypted notes)."""
+        return _replace(note.text or "", self.for_note(note.id))
+
+    def notes_affected(self) -> int:
+        return len({f.note_id for f in self.findings})
+
+
+def scan_notes(notes: list[Note]) -> ScanReport:
+    """Scan every note; the report carries the findings and can redact."""
+    plugins = _build_plugins()
+    findings: list[SecretFinding] = []
+    for note in notes:
+        findings.extend(_scan_note(note, plugins))
+    return ScanReport(findings)

bearkit-1.6.0.dist-info/METADATA

@@ -0,0 +1,39 @@
+Metadata-Version: 2.4
+Name: bearkit
+Version: 1.6.0
+Summary: Python toolkit for the Bear notes app — read, search, secret detection, and verified writes
+Keywords: bear,notes,markdown,macos
+Author: Michel Tricot
+Author-email: Michel Tricot <michel.tricot@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Operating System :: MacOS
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries
+Requires-Dist: detect-secrets>=1.5.0
+Requires-Dist: rapidfuzz>=3.14.5
+Requires-Python: >=3.13
+Project-URL: Documentation, https://github.com/michel-tricot/bearcli/blob/main/docs/BEARKIT.md
+Project-URL: Homepage, https://michel-tricot.github.io/bearcli/
+Project-URL: Repository, https://github.com/michel-tricot/bearcli
+Description-Content-Type: text/markdown
+
+# 🐻 `bearkit`
+
+The Python toolkit for the [Bear](https://bear.app) notes app: read your
+notes, write them through the Bear app with verification, search them, and
+detect secrets - all offline. macOS only.
+
+```python
+from bearkit import Bear
+
+with Bear() as bear:
+    for note in bear.list_notes(tag="work", limit=10):
+        print(note.title)
+```
+
+Full API reference:
+[docs/BEARKIT.md](https://github.com/michel-tricot/bearcli/blob/main/docs/BEARKIT.md).
+`bearkit` powers [`bearcli`](https://pypi.org/project/bearcli/), the CLI and
+terminal UI; install that for the full tool.

bearkit-1.6.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+bearkit/__init__.py,sha256=9gCu5LUwl2eO_pmFPCsuwLm9p2lKXrKKPNl5ar8NM88,1611
+bearkit/actions.py,sha256=nKhu4iUjS6-SAvsJKvoTqPRa0mj9lD9zKAOFJKb9OZY,2430
+bearkit/bear.py,sha256=I5ZS8ZI07UDMMyflupFcl6L2XSeZBv_fHtqUYGPtkV0,6555
+bearkit/db.py,sha256=WvXRuB4fHDZIlXH2NgHVo3HD8MzOMYzByG3nasYUeGQ,12946
+bearkit/markdown.py,sha256=tTviQilh8iCMubU3Xif-yfx1z-OP3YMzbWWAOE53y3g,1734
+bearkit/ops.py,sha256=pzmQDyOEhY-vYup7QYyVxlTJG4CCvH-xxLY_v4_GsgM,5492
+bearkit/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+bearkit/search.py,sha256=KRvlBpd9jYpUbbnnT17kn4NHueR280lURxMgzICH1ZY,4814
+bearkit/secrets.py,sha256=0XaI2o49sOo3sCS6lDIT_LmkLR3czx622CTu3AnIR6w,9077
+bearkit-1.6.0.dist-info/licenses/LICENSE,sha256=6GQ08_KAylombOwcGnemMQM8Ai39XsWdW25vHPE6v_s,1070
+bearkit-1.6.0.dist-info/WHEEL,sha256=eh7sammvW2TypMMMGKgsM83HyA_3qQ5Lgg3ynoecH3M,79
+bearkit-1.6.0.dist-info/METADATA,sha256=st_vccwU2zCjvw06qXvQgEqTFA7KYrlRB1TbN57Px9U,1453
+bearkit-1.6.0.dist-info/RECORD,,

bearkit-1.6.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.8.24
+Root-Is-Purelib: true
+Tag: py3-none-any

bearkit-1.6.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Michel Tricot
+
+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.