pynakes 0.5.1__py3-none-any.whl

pynakes/__init__.py

@@ -0,0 +1,8 @@
+"""pynakes: Agent-friendly BibTeX library management."""
+
+from importlib.metadata import PackageNotFoundError, version
+
+try:
+    __version__ = version("pynakes")
+except PackageNotFoundError:  # running from a source tree that isn't installed
+    __version__ = "0.0.0+unknown"

pynakes/__main__.py

@@ -0,0 +1,6 @@
+"""Entry point for running pynakes as a module."""
+
+from pynakes.cli import app
+
+if __name__ == "__main__":
+    app()

pynakes/_calendar.py

@@ -0,0 +1,58 @@
+"""Canonical month name/number tables shared across pynakes.
+
+Consolidates month-related data that was previously defined independently in
+:mod:`pynakes.model`, :mod:`pynakes.interchange._shared`, and
+:mod:`pynakes.formatters._date`.  All three now import from this module,
+guaranteeing a single source of truth.
+"""
+
+# Three-letter BibTeX month macros (lowercase) mapped to full month names.
+# This is the same dict historically exposed as ``COMMON_STRINGS`` in model.py.
+MONTH_ABBR_TO_NAME: dict[str, str] = {
+    "jan": "January",
+    "feb": "February",
+    "mar": "March",
+    "apr": "April",
+    "may": "May",
+    "jun": "June",
+    "jul": "July",
+    "aug": "August",
+    "sep": "September",
+    "oct": "October",
+    "nov": "November",
+    "dec": "December",
+}
+
+MONTH_ABBRS: list[str] = list(MONTH_ABBR_TO_NAME)
+
+MONTH_NAMES: list[str] = [name.lower() for name in MONTH_ABBR_TO_NAME.values()]
+
+# Three-letter macro → month number string (1-12, BibTeX-compatible).
+# This is the same dict historically exposed as ``MONTH_NUMBERS`` in
+# :mod:`pynakes.interchange._shared`.
+MONTH_ABBR_TO_NUM: dict[str, str] = {
+    "jan": "1",
+    "feb": "2",
+    "mar": "3",
+    "apr": "4",
+    "may": "5",
+    "jun": "6",
+    "jul": "7",
+    "aug": "8",
+    "sep": "9",
+    "oct": "10",
+    "nov": "11",
+    "dec": "12",
+}
+
+# Any month name (three-letter abbreviation or full lowercase) → 1-based int.
+_MONTH_TO_NUM: dict[str, int] = {name: i + 1 for i, name in enumerate(MONTH_ABBRS)}
+_MONTH_TO_NUM.update({name: i + 1 for i, name in enumerate(MONTH_NAMES)})
+
+# Two-digit month number string → three-letter abbreviation.
+MONTH_NUM_TO_ABBR: dict[str, str] = {f"{i + 1:02d}": abbr for i, abbr in enumerate(MONTH_ABBRS)}
+
+
+def month_name_to_int(token: str) -> int | None:
+    """Return 1-12 for a month name/abbreviation, or ``None``."""
+    return _MONTH_TO_NUM.get(token.strip().lower().rstrip("."))

pynakes/_engine_groups.py

@@ -0,0 +1,88 @@
+"""Group-operation mixin for :class:`~pynakes.engine.Bibliography`.
+
+All methods here delegate to :mod:`pynakes.groups` / :mod:`pynakes.group_tree`;
+the engine derives staged state from their model mutations. Do not import this
+module directly; use ``pynakes.engine``.
+"""
+
+from __future__ import annotations
+
+from pynakes import group_tree as group_tree_ops
+from pynakes import groups as group_ops
+
+
+class BibliographyGroups:
+    """Mixin providing group-tree operations for :class:`~pynakes.engine.Bibliography`.
+
+    Consumers must not instantiate this class directly.
+    """
+
+    def list_groups(self) -> list[str]:
+        """Return all group names in first-seen order."""
+        return group_ops.list_groups(self.lib)
+
+    def list_entries_in_group(self, group: str) -> list[str]:
+        """Return entry keys that belong to ``group``."""
+        return group_ops.list_entries_in_group(self.lib, group)
+
+    def add_to_group(self, key: str, group: str) -> int:
+        """Add every entry with ``key`` to ``group``.
+
+        When the library has a group-tree, the group is also registered as a node
+        so the new membership is visible to ``groups tree``/``groups list`` and to
+        JabRef: an entry ``groups={X}`` with no ``X`` in the tree is an orphan
+        membership, invisible everywhere the tree drives the view. Flat, tree-less
+        libraries keep entry-field-only groups (surfaced by ``groups list``).
+        """
+        count = group_ops.add_to_group(self.lib, key, group)
+        if count and group_tree_ops.list_tree(self.lib) is not None:
+            group_tree_ops.add_node(self.lib, group)  # no-op if already a node
+        return count
+
+    def remove_from_group(self, key: str, group: str) -> int:
+        """Remove every entry with ``key`` from ``group``."""
+        count = group_ops.remove_from_group(self.lib, key, group)
+        return count
+
+    def list_tree(self) -> list[group_tree_ops.GroupNode] | None:
+        """Return the group hierarchy tree, or ``None`` if none defined."""
+        return group_tree_ops.list_tree(self.lib)
+
+    def add_group_node(
+        self,
+        name: str,
+        *,
+        parent: str = "",
+        context: int = 2,
+        color: str = "",
+        expanded: bool = True,
+    ) -> bool:
+        """Add a group node to the tree."""
+        ok = group_tree_ops.add_node(
+            self.lib, name, parent=parent, context=context, color=color, expanded=expanded
+        )
+        return ok
+
+    def remove_group_node(self, name: str) -> int:
+        """Remove a group node and its descendants from the tree."""
+        count = group_tree_ops.remove_node(self.lib, name)
+        return count
+
+    def rename_group_node(self, old_name: str, new_name: str) -> bool:
+        """Rename a group node, updating parent references in children."""
+        ok = group_tree_ops.rename_node(self.lib, old_name, new_name)
+        return ok
+
+    def move_group_node(self, name: str, new_parent: str) -> bool:
+        """Move a group node to a new parent."""
+        ok = group_tree_ops.move_node(self.lib, name, new_parent)
+        return ok
+
+    def update_group_node(self, name: str, **kwargs) -> bool:
+        """Update properties of a group node."""
+        ok = group_tree_ops.update_node(self.lib, name, **kwargs)
+        return ok
+
+    def list_entries_in_group_tree(self, group: str, *, strict: bool = False) -> list[str]:
+        """Return entry keys in *group*, including descendants unless *strict*."""
+        return group_tree_ops.list_entries_in_group_tree(self.lib, group, strict=strict)