rustfava 0.1.0__py3-none-any.whl

rustfava/plugins/__init__.py

@@ -0,0 +1,3 @@
+"""Some Beancount plugins."""
+
+from __future__ import annotations

rustfava/plugins/link_documents.py

@@ -0,0 +1,107 @@
+"""Beancount plugin to link entries to documents.
+
+It goes through all entries with a `document` metadata-key, and tries to
+associate them to Document entries. For transactions, it then also adds a link
+from the transaction to documents, as well as the "#linked" tag.
+"""
+
+from __future__ import annotations
+
+from collections import defaultdict
+from pathlib import Path
+from typing import Any
+from typing import TYPE_CHECKING
+
+from rustfava.beans.abc import Document
+from rustfava.beans.account import get_entry_accounts
+from rustfava.beans.funcs import get_position
+from rustfava.beans.helpers import replace
+from rustfava.helpers import BeancountError
+from rustfava.util.sets import add_to_set
+
+if TYPE_CHECKING:  # pragma: no cover
+    from collections.abc import Sequence
+
+    from rustfava.beans.abc import Directive
+
+
+class DocumentError(BeancountError):
+    """Document-linking related error."""
+
+
+__plugins__ = ["link_documents"]
+
+
+def link_documents(
+    entries: Sequence[Directive],
+    _: Any,
+) -> tuple[Sequence[Directive], list[DocumentError]]:
+    """Link entries to documents."""
+    errors = []
+
+    # All document indices by their full file path.
+    by_fullname = {}
+    # All document indices by their file basename.
+    by_basename = defaultdict(list)
+
+    for index, entry in enumerate(entries):
+        if isinstance(entry, Document):
+            by_fullname[entry.filename] = index
+            by_basename[Path(entry.filename).name].append((index, entry))
+
+    new_entries = list(entries)
+    for index, entry in enumerate(entries):
+        disk_docs = [
+            value
+            for key, value in entry.meta.items()
+            if key.startswith("document") and isinstance(value, str)
+        ]
+
+        if not disk_docs:
+            continue
+
+        # Link the documents by using the entry date. This means that this will
+        # not necessarily be unique, but it shows which date the linked entry
+        # is on (and it will probably narrow it down enough)
+        entry_link = f"dok-{entry.date}"
+        entry_accounts = get_entry_accounts(entry)
+        entry_filename, _ = get_position(entry)
+        for disk_doc in disk_docs:
+            documents = [
+                j
+                for j, document in by_basename[disk_doc]
+                if document.account in entry_accounts
+            ]
+            disk_doc_path = str(
+                (Path(entry_filename).parent / disk_doc).resolve()
+            )
+            if disk_doc_path in by_fullname:
+                documents.append(by_fullname[disk_doc_path])
+
+            if not documents:
+                errors.append(
+                    DocumentError(
+                        entry.meta, f"Document not found: '{disk_doc}'", entry
+                    ),
+                )
+                continue
+
+            for j in documents:
+                # Since we might link a document multiple times, we have to use
+                # the index for the replacement here.
+                doc: Document = new_entries[j]  # type: ignore[assignment]
+                new_entries[j] = replace(
+                    doc,
+                    links=add_to_set(doc.links, entry_link),
+                    tags=add_to_set(doc.tags, "linked"),
+                )
+
+            # Not all entry types support links, so only add links for the ones
+            # that do.
+            if hasattr(entry, "links"):
+                new_entries[index] = replace(
+                    entry,
+                    links=add_to_set(entry.links, entry_link),  # ty:ignore[invalid-argument-type]
+                )
+
+    return new_entries, errors

rustfava/plugins/tag_discovered_documents.py

@@ -0,0 +1,44 @@
+"""Beancount plugin to tag discovered documents.
+
+It looks through all Document entries that were added by Beancount
+automatically through file discovery and adds the tag "#discovered".
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from rustfava.beans.abc import Document
+from rustfava.beans.helpers import replace
+from rustfava.util.sets import add_to_set
+
+if TYPE_CHECKING:  # pragma: no cover
+    from collections.abc import Iterator
+    from collections.abc import Sequence
+
+    from rustfava.beans.abc import Directive
+    from rustfava.beans.types import BeancountOptions
+    from rustfava.helpers import BeancountError
+
+__plugins__ = ["tag_discovered_documents"]
+
+
+def tag_discovered_documents(
+    entries: Sequence[Directive],
+    options_map: BeancountOptions,
+) -> tuple[Sequence[Directive], list[BeancountError]]:
+    """Tag automatically added documents."""
+    if not options_map["documents"]:  # pragma: no cover
+        return entries, []
+
+    def _tag_discovered() -> Iterator[Directive]:
+        for entry in entries:
+            if isinstance(entry, Document) and entry.meta["lineno"] == 0:
+                yield replace(
+                    entry,
+                    tags=add_to_set(entry.tags, "discovered"),
+                )
+            else:
+                yield entry
+
+    return list(_tag_discovered()), []

rustfava/rustledger/__init__.py

@@ -0,0 +1,31 @@
+"""Rustledger WASM integration for Fava.
+
+This module provides a Python interface to rustledger via wasmtime-py,
+replacing beancount for parsing, validation, and querying.
+"""
+
+from __future__ import annotations
+
+from rustfava.rustledger.engine import RustledgerEngine
+from rustfava.rustledger.loader import load_string
+from rustfava.rustledger.loader import load_uncached
+
+
+def is_encrypted_file(path: str) -> bool:
+    """Check if a file is GPG encrypted.
+
+    Args:
+        path: Path to file
+
+    Returns:
+        True if file is encrypted
+    """
+    return RustledgerEngine.get_instance().is_encrypted(path)
+
+
+__all__ = [
+    "RustledgerEngine",
+    "is_encrypted_file",
+    "load_string",
+    "load_uncached",
+]

rustfava/rustledger/constants.py

@@ -0,0 +1,76 @@
+"""Type constants for rustledger - replaces beancount type constants."""
+
+from __future__ import annotations
+
+from enum import Enum
+
+
+# Account type sentinel - used in Custom entries to identify account values
+# This matches beancount's '<AccountDummy>' sentinel
+ACCOUNT_TYPE = "<AccountDummy>"
+
+
+class Booking(Enum):
+    """Booking methods for inventory reduction."""
+
+    STRICT = "STRICT"
+    STRICT_WITH_SIZE = "STRICT_WITH_SIZE"
+    FIFO = "FIFO"
+    LIFO = "LIFO"
+    HIFO = "HIFO"
+    AVERAGE = "AVERAGE"
+    NONE = "NONE"
+
+
+class Missing:
+    """Sentinel for missing/incomplete posting amounts.
+
+    This represents an amount that should be interpolated by the booking system.
+    """
+
+    _instance: Missing | None = None
+
+    def __new__(cls) -> Missing:
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+        return cls._instance
+
+    def __repr__(self) -> str:
+        return "MISSING"
+
+    def __bool__(self) -> bool:
+        return False
+
+
+# Singleton instance
+MISSING = Missing()
+
+
+# All directive type names
+ALL_DIRECTIVES = frozenset([
+    "Transaction",
+    "Balance",
+    "Open",
+    "Close",
+    "Commodity",
+    "Pad",
+    "Event",
+    "Query",
+    "Note",
+    "Document",
+    "Price",
+    "Custom",
+    # Rustledger prefixed versions
+    "RLTransaction",
+    "RLBalance",
+    "RLOpen",
+    "RLClose",
+    "RLCommodity",
+    "RLPad",
+    "RLEvent",
+    "RLQuery",
+    "RLNote",
+    "RLDocument",
+    "RLPrice",
+    "RLCustom",
+])