rustfava 0.1.0__py3-none-any.whl

rustfava/rustledger/loader.py

@@ -0,0 +1,273 @@
+"""Loader functions for rustledger - replaces beancount.loader."""
+
+from __future__ import annotations
+
+from collections import Counter
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from rustfava.rustledger.engine import RustledgerEngine
+from rustfava.rustledger.options import options_from_json
+from rustfava.rustledger.types import directives_from_json
+
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+    from typing import Any
+
+    from rustfava.beans.abc import Directive
+    from rustfava.beans.types import BeancountOptions
+    from rustfava.helpers import BeancountError
+
+
+def _compute_display_precision(entries_json: list[dict[str, Any]]) -> dict[str, int]:
+    """Compute display precision from entries.
+
+    This is a workaround until rustledger FFI returns display_precision
+    from load-full command.
+    """
+    # Track precision counts per currency: {currency: {precision: count}}
+    precision_counts: dict[str, Counter[int]] = {}
+
+    def track_amount(amt: dict[str, Any] | None) -> None:
+        if not amt:
+            return
+        number_str = amt.get("number", "")
+        currency = amt.get("currency", "")
+        if not number_str or not currency:
+            return
+        # Calculate precision from decimal places
+        if "." in str(number_str):
+            precision = len(str(number_str).split(".")[-1])
+        else:
+            precision = 0
+        if currency not in precision_counts:
+            precision_counts[currency] = Counter()
+        precision_counts[currency][precision] += 1
+
+    for entry in entries_json:
+        entry_type = entry.get("type", "")
+
+        if entry_type == "transaction":
+            for posting in entry.get("postings", []):
+                track_amount(posting.get("units"))
+                if posting.get("cost"):
+                    cost = posting["cost"]
+                    track_amount({"number": cost.get("number"), "currency": cost.get("currency")})
+                track_amount(posting.get("price"))
+
+        elif entry_type == "balance":
+            track_amount(entry.get("amount"))
+
+        elif entry_type == "price":
+            track_amount(entry.get("amount"))
+
+    # Get most common precision for each currency
+    result = {}
+    for currency, counts in precision_counts.items():
+        if counts:
+            result[currency] = counts.most_common(1)[0][0]
+
+    return result
+
+
+def _errors_from_json(
+    errors_json: list[dict[str, Any]],
+    filename: str = "<unknown>",
+) -> list[BeancountError]:
+    """Convert rustledger errors to Fava BeancountError format."""
+    from rustfava.helpers import BeancountError
+
+    result = []
+    for err in errors_json:
+        # Handle both old format (source dict) and new format (line field)
+        if "source" in err:
+            source = err["source"]
+            err_filename = source.get("filename", filename)
+            err_lineno = source.get("lineno", 0)
+        else:
+            err_filename = err.get("filename", filename)
+            err_lineno = err.get("line", 0)
+
+        result.append(
+            BeancountError(
+                source={
+                    "filename": err_filename,
+                    "lineno": err_lineno,
+                },
+                message=err.get("message", "Unknown error"),
+                entry=None,
+            )
+        )
+    return result
+
+
+def _run_plugins(
+    entries: list[Directive],
+    plugins: list[dict[str, Any]],
+    options: BeancountOptions,
+) -> tuple[list[Directive], list[BeancountError]]:
+    """Run Python plugins on entries.
+
+    Args:
+        entries: List of parsed entries
+        plugins: List of plugin specs from rustledger ({"name": "...", "config": "..."})
+        options: Beancount options dict
+
+    Returns:
+        Tuple of (processed entries, plugin errors)
+    """
+    import importlib
+
+    from rustfava.helpers import BeancountError
+
+    all_errors: list[BeancountError] = []
+
+    for plugin_spec in plugins:
+        plugin_name = plugin_spec.get("name", "")
+        plugin_config = plugin_spec.get("config")
+
+        if not plugin_name:
+            continue
+
+        # Skip beancount.plugins.auto_accounts - handled natively by rustledger
+        if plugin_name == "beancount.plugins.auto_accounts":
+            continue
+
+        try:
+            module = importlib.import_module(plugin_name)
+        except ImportError as e:
+            all_errors.append(
+                BeancountError(
+                    source={"filename": "<plugin>", "lineno": 0},
+                    message=f"Failed to import plugin '{plugin_name}': {e}",
+                    entry=None,
+                )
+            )
+            continue
+
+        # Get plugin functions from __plugins__ attribute
+        plugin_funcs = getattr(module, "__plugins__", [])
+        if not plugin_funcs:
+            # Try using the module name as the function name
+            func_name = plugin_name.split(".")[-1]
+            if hasattr(module, func_name):
+                plugin_funcs = [func_name]
+
+        for func_name in plugin_funcs:
+            plugin_fn = getattr(module, func_name, None)
+            if plugin_fn is None:
+                continue
+
+            try:
+                # Call plugin: (entries, options) -> (entries, errors)
+                if plugin_config is not None:
+                    entries, plugin_errors = plugin_fn(entries, plugin_config)
+                else:
+                    entries, plugin_errors = plugin_fn(entries, options)
+
+                # Convert any plugin errors to our error format
+                for err in plugin_errors:
+                    if isinstance(err, BeancountError):
+                        all_errors.append(err)
+                    else:
+                        all_errors.append(
+                            BeancountError(
+                                source=getattr(err, "source", {"filename": "<plugin>", "lineno": 0}),
+                                message=getattr(err, "message", str(err)),
+                                entry=getattr(err, "entry", None),
+                            )
+                        )
+            except Exception as e:
+                all_errors.append(
+                    BeancountError(
+                        source={"filename": "<plugin>", "lineno": 0},
+                        message=f"Plugin '{plugin_name}.{func_name}' raised: {e}",
+                        entry=None,
+                    )
+                )
+
+    return list(entries), all_errors
+
+
+def load_string(
+    value: str,
+    filename: str = "<string>",
+) -> tuple[
+    Sequence[Directive],
+    Sequence[BeancountError],
+    BeancountOptions,
+]:
+    """Load a Beancount string.
+
+    Args:
+        value: Beancount source code
+        filename: Filename to use in metadata
+
+    Returns:
+        Tuple of (entries, errors, options)
+    """
+    engine = RustledgerEngine.get_instance()
+    result = engine.load(value, filename)
+
+    entries = list(directives_from_json(result.get("entries", [])))
+    errors = list(_errors_from_json(result.get("errors", []), filename))
+    options = options_from_json(result.get("options", {}))
+
+    # Run Python plugins if any are specified
+    plugins = result.get("plugins", [])
+    if plugins:
+        entries, plugin_errors = _run_plugins(entries, plugins, options)
+        errors.extend(plugin_errors)
+
+    return entries, errors, options
+
+
+def load_uncached(
+    beancount_file_path: str,
+    *,
+    is_encrypted: bool = False,
+) -> tuple[
+    Sequence[Directive],
+    Sequence[BeancountError],
+    BeancountOptions,
+]:
+    """Load a Beancount file.
+
+    Uses rustledger's load-full command which handles:
+    - Include resolution with cycle detection
+    - Path security (prevents path traversal)
+    - GPG decryption for encrypted files
+    - Native plugin execution (auto_accounts)
+    - Entry sorting
+
+    Args:
+        beancount_file_path: Path to the main beancount file
+        is_encrypted: Ignored - rustledger handles GPG decryption
+
+    Returns:
+        Tuple of (entries, errors, options)
+    """
+    del is_encrypted  # Rustledger handles GPG decryption automatically
+
+    main_path = Path(beancount_file_path)
+    engine = RustledgerEngine.get_instance()
+
+    # Use load_full with auto_accounts plugin for sorting and account generation
+    result = engine.load_full(str(main_path), plugins=["auto_accounts"])
+
+    entries_json = result.get("entries", [])
+
+    # Compute display_precision if not provided by FFI (workaround)
+    options_json = result.get("options", {})
+    if not options_json.get("display_precision"):
+        options_json["display_precision"] = _compute_display_precision(entries_json)
+
+    entries = directives_from_json(entries_json)
+    errors = list(_errors_from_json(result.get("errors", []), str(main_path)))
+    options = options_from_json(options_json)
+
+    # Set include list and filename in options
+    options["include"] = result.get("loaded_files", [str(main_path)])
+    options["filename"] = str(main_path)
+
+    return entries, errors, options

rustfava/rustledger/options.py

@@ -0,0 +1,202 @@
+"""Options adapter for rustledger JSON to Fava's BeancountOptions."""
+
+from __future__ import annotations
+
+from decimal import Decimal
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from typing import Any
+
+    from rustfava.beans.types import BeancountOptions
+
+
+class _RLCurrencyContext:
+    """Minimal CurrencyContext for a single currency."""
+
+    def __init__(self, precision: int) -> None:
+        self._precision = precision
+
+    def get_fractional(self, _precision_type: Any = None) -> int:
+        """Return the fractional precision (beancount-compatible API)."""
+        return self._precision
+
+
+class RLDisplayContext:
+    """Minimal DisplayContext implementation for rustledger.
+
+    This replaces beancount.core.display_context.DisplayContext.
+    Provides beancount-compatible `ccontexts` property.
+    """
+
+    def __init__(self, options: dict[str, Any]) -> None:
+        """Initialize from rustledger options."""
+        self._precision = options.get("display_precision", {})
+        self._render_commas = options.get("render_commas", True)
+        # Beancount-compatible ccontexts mapping
+        self.ccontexts = {
+            currency: _RLCurrencyContext(prec)
+            for currency, prec in self._precision.items()
+        }
+
+    def build(self) -> RLDisplayFormatter:
+        """Build a formatter from this context."""
+        return RLDisplayFormatter(self._precision, self._render_commas)
+
+
+class RLDisplayFormatter:
+    """Formatter for decimal numbers."""
+
+    def __init__(
+        self,
+        precision: dict[str, int],
+        render_commas: bool,
+    ) -> None:
+        """Initialize formatter."""
+        self._precision = precision
+        self._render_commas = render_commas
+
+    def format(self, number: Decimal, currency: str) -> str:
+        """Format a decimal number for a currency."""
+        prec = self._precision.get(currency, 2)
+        formatted = f"{number:.{prec}f}"
+        if self._render_commas:
+            # Add thousand separators
+            parts = formatted.split(".")
+            parts[0] = "{:,}".format(int(parts[0]))
+            formatted = ".".join(parts)
+        return formatted
+
+    def quantize(
+        self,
+        number: Decimal,
+        currency: str = "__default__",
+    ) -> Decimal:
+        """Quantize a number to the precision for a currency.
+
+        This matches beancount's DisplayFormatter.quantize interface.
+        """
+        prec = self._precision.get(currency, 2)
+        # Create a Decimal with the right number of decimal places
+        quantizer = Decimal(10) ** -prec
+        return number.quantize(quantizer)
+
+
+class RLBooking:
+    """Booking method enum compatible with beancount.core.data.Booking."""
+
+    STRICT = "STRICT"
+    FIFO = "FIFO"
+    LIFO = "LIFO"
+    HIFO = "HIFO"
+    AVERAGE = "AVERAGE"
+    NONE = "NONE"
+
+    def __init__(self, value: str) -> None:
+        """Initialize from string value."""
+        self.value = value.upper() if value else "STRICT"
+
+    def __str__(self) -> str:
+        """Return string representation."""
+        return self.value
+
+    def __eq__(self, other: object) -> bool:
+        """Check equality."""
+        if isinstance(other, str):
+            return self.value == other.upper()
+        if isinstance(other, RLBooking):
+            return self.value == other.value
+        return False
+
+
+def options_from_json(data: dict[str, Any]) -> BeancountOptions:
+    """Convert rustledger options JSON to Fava's BeancountOptions.
+
+    Args:
+        data: JSON dict of options from rustledger
+
+    Returns:
+        BeancountOptions TypedDict
+    """
+    # Create display context
+    dcontext = RLDisplayContext(data)
+
+    # Parse display_precision
+    display_precision = {
+        k: Decimal(str(v))
+        for k, v in data.get("display_precision", {}).items()
+    }
+
+    # Parse inferred_tolerance_default
+    inferred_tolerance_default = {
+        k: Decimal(str(v))
+        for k, v in data.get("inferred_tolerance_default", {}).items()
+    }
+
+    options: BeancountOptions = {
+        "title": data.get("title", ""),
+        "filename": data.get("filename", ""),
+        # Root account names
+        "name_assets": data.get("name_assets", "Assets"),
+        "name_liabilities": data.get("name_liabilities", "Liabilities"),
+        "name_equity": data.get("name_equity", "Equity"),
+        "name_income": data.get("name_income", "Income"),
+        "name_expenses": data.get("name_expenses", "Expenses"),
+        # Special accounts
+        "account_current_conversions": data.get(
+            "account_current_conversions", "Equity:Conversions:Current"
+        ),
+        "account_current_earnings": data.get(
+            "account_current_earnings", "Equity:Earnings:Current"
+        ),
+        "account_previous_balances": data.get(
+            "account_previous_balances", "Equity:Opening-Balances"
+        ),
+        "account_previous_conversions": data.get(
+            "account_previous_conversions", "Equity:Conversions:Previous"
+        ),
+        "account_previous_earnings": data.get(
+            "account_previous_earnings", "Equity:Earnings:Previous"
+        ),
+        "account_rounding": data.get("account_rounding"),
+        "account_unrealized_gains": data.get(
+            "account_unrealized_gains", "Income:Unrealized"
+        ),
+        # Booking and commodities
+        "booking_method": RLBooking(data.get("booking_method", "STRICT")),
+        "commodities": set(data.get("commodities", [])),
+        "conversion_currency": data.get("conversion_currency", ""),
+        "dcontext": dcontext,
+        "display_precision": display_precision,
+        # File handling
+        "documents": list(data.get("documents", [])),
+        "include": list(data.get("include", [])),
+        # Tolerances
+        "infer_tolerance_from_cost": data.get("infer_tolerance_from_cost", False),
+        "inferred_tolerance_default": inferred_tolerance_default,
+        "inferred_tolerance_multiplier": Decimal(
+            str(data.get("inferred_tolerance_multiplier", "0.5"))
+        ),
+        "input_hash": data.get("input_hash", ""),
+        "insert_pythonpath": data.get("insert_pythonpath", False),
+        "operating_currency": list(data.get("operating_currency", [])),
+        # Plugins (won't work with rustledger, but keep for compatibility)
+        "plugin": list(
+            tuple(p) if isinstance(p, list) else (p, None)
+            for p in data.get("plugin", [])
+        ),
+        "plugin_processing_mode": data.get("plugin_processing_mode", ""),
+        "pythonpath": list(data.get("pythonpath", [])),
+        "render_commas": data.get("render_commas", False),
+        "tolerance_multiplier": Decimal(
+            str(data.get("tolerance_multiplier", "1.0"))
+        ),
+        # Deprecated options (for compatibility)
+        "allow_deprecated_none_for_tags_and_links": data.get(
+            "allow_deprecated_none_for_tags_and_links", False
+        ),
+        "allow_pipe_separator": data.get("allow_pipe_separator", False),
+        "long_string_maxlines": data.get("long_string_maxlines", 64),
+    }
+
+    return options