rustfava 0.1.0__py3-none-any.whl

rustfava/beans/types.py

@@ -0,0 +1,63 @@
+"""Typing helpers."""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+from decimal import Decimal
+from typing import Any
+from typing import TypedDict
+
+from rustfava.beans.abc import Directive
+from rustfava.helpers import BeancountError
+
+
+class BeancountOptions(TypedDict):
+    """Beancount options."""
+
+    title: str
+    filename: str
+
+    name_assets: str
+    name_liabilities: str
+    name_equity: str
+    name_income: str
+    name_expenses: str
+
+    account_current_conversions: str
+    account_current_earnings: str
+    account_previous_balances: str
+    account_previous_conversions: str
+    account_previous_earnings: str
+    account_rounding: str | None
+    account_unrealized_gains: str
+
+    booking_method: Any  # beancount.core.data.Booking enum
+    commodities: set[str]
+    conversion_currency: str
+    dcontext: Any  # beancount.core.display_context.DisplayContext
+    display_precision: dict[str, Decimal]
+    documents: Sequence[str]
+    include: Sequence[str]
+    infer_tolerance_from_cost: bool
+    inferred_tolerance_default: dict[str, Decimal]
+    inferred_tolerance_multiplier: Decimal
+    input_hash: str
+    insert_pythonpath: bool
+    operating_currency: Sequence[str]
+    plugin: Sequence[tuple[str, str | None]]
+    plugin_processing_mode: str
+    pythonpath: Sequence[str]
+    render_commas: bool
+    tolerance_multiplier: Decimal
+
+    # deprecated ones
+    allow_deprecated_none_for_tags_and_links: bool
+    allow_pipe_separator: bool
+    long_string_maxlines: int
+
+
+LoaderResult = tuple[
+    Sequence[Directive],
+    Sequence[BeancountError],
+    BeancountOptions,
+]

rustfava/cli.py

@@ -0,0 +1,187 @@
+"""The command-line interface for rustfava."""
+
+from __future__ import annotations
+
+import errno
+import os
+from pathlib import Path
+
+import click
+
+
+class AddressInUse(click.ClickException):  # noqa: D101
+    def __init__(self, port: int) -> None:  # pragma: no cover
+        super().__init__(
+            f"Cannot start rustfava because port {port} is already in use."
+            "\nPlease choose a different port with the '-p' option.",
+        )
+
+
+class NonAbsolutePathError(click.UsageError):  # noqa: D101
+    def __init__(self, path: str) -> None:
+        super().__init__(
+            f"Paths in BEANCOUNT_FILE need to be absolute: {path}"
+        )
+
+
+class NoFileSpecifiedError(click.UsageError):  # noqa: D101
+    def __init__(self) -> None:  # pragma: no cover
+        super().__init__("No file specified")
+
+
+def _add_env_filenames(filenames: tuple[str, ...]) -> tuple[str, ...]:
+    """Read additional filenames from BEANCOUNT_FILE."""
+    env_filename = os.environ.get("BEANCOUNT_FILE")
+    if not env_filename:
+        return tuple(dict.fromkeys(filenames))
+
+    env_names = env_filename.split(os.pathsep)
+    for name in env_names:
+        if not Path(name).is_absolute():
+            raise NonAbsolutePathError(name)
+
+    all_names = tuple(env_names) + filenames
+    return tuple(dict.fromkeys(all_names))
+
+
+@click.command(context_settings={"auto_envvar_prefix": "RUSTFAVA"})
+@click.argument(
+    "filenames",
+    nargs=-1,
+    type=click.Path(exists=True, dir_okay=False, resolve_path=True),
+)
+@click.option(
+    "-p",
+    "--port",
+    type=int,
+    default=5000,
+    show_default=True,
+    metavar="<port>",
+    help="The port to listen on.",
+)
+@click.option(
+    "-H",
+    "--host",
+    type=str,
+    default="localhost",
+    show_default=True,
+    metavar="<host>",
+    help="The host to listen on.",
+)
+@click.option("--prefix", type=str, help="Set an URL prefix.")
+@click.option(
+    "--incognito",
+    is_flag=True,
+    help="Run in incognito mode and obscure all numbers.",
+)
+@click.option(
+    "--read-only",
+    is_flag=True,
+    help="Run in read-only mode, disable any change through rustfava.",
+)
+@click.option("-d", "--debug", is_flag=True, help="Turn on debugging.")
+@click.option(
+    "--profile",
+    is_flag=True,
+    help="Turn on profiling. Implies --debug.",
+)
+@click.option(
+    "--profile-dir",
+    type=click.Path(),
+    help="Output directory for profiling data.",
+)
+@click.option(
+    "--poll-watcher", is_flag=True, help="Use old polling-based watcher."
+)
+@click.version_option(package_name="rustfava")
+def main(  # noqa: PLR0913
+    *,
+    filenames: tuple[str, ...] = (),
+    port: int = 5000,
+    host: str = "localhost",
+    prefix: str | None = None,
+    incognito: bool = False,
+    read_only: bool = False,
+    debug: bool = False,
+    profile: bool = False,
+    profile_dir: str | None = None,
+    poll_watcher: bool = False,
+) -> None:  # pragma: no cover
+    """Start Rustfava for FILENAMES on http://<host>:<port>.
+
+    If the `BEANCOUNT_FILE` environment variable is set, Rustfava will use the
+    files (delimited by ';' on Windows and ':' on POSIX) given there in
+    addition to FILENAMES.
+
+    Note you can also specify command-line options via environment variables
+    with the `RUSTFAVA_` prefix. For example, `--host=0.0.0.0` is equivalent to
+    setting the environment variable `RUSTFAVA_HOST=0.0.0.0`.
+    """
+    all_filenames = _add_env_filenames(filenames)
+
+    if not all_filenames:
+        raise NoFileSpecifiedError
+
+    from rustfava.application import create_app
+
+    app = create_app(
+        all_filenames,
+        incognito=incognito,
+        read_only=read_only,
+        poll_watcher=poll_watcher,
+    )
+
+    if prefix:
+        from werkzeug.middleware.dispatcher import DispatcherMiddleware
+
+        from rustfava.util import simple_wsgi
+
+        app.wsgi_app = DispatcherMiddleware(  # type: ignore[method-assign]
+            simple_wsgi,
+            {prefix: app.wsgi_app},
+        )
+
+    # ensure that cheroot does not use IP6 for localhost
+    host = "127.0.0.1" if host == "localhost" else host
+    # Debug mode if profiling is active
+    debug = debug or profile
+
+    click.secho(f"Starting Fava on http://{host}:{port}", fg="green")
+    if not debug:
+        from cheroot.wsgi import Server
+
+        server = Server((host, port), app)
+        try:
+            server.start()
+        except KeyboardInterrupt:
+            click.echo("Keyboard interrupt received: stopping Fava", err=True)
+            server.stop()
+        except OSError as error:
+            if "No socket could be created" in str(error):
+                raise AddressInUse(port) from error
+            raise click.Abort from error
+    else:
+        from werkzeug.middleware.profiler import ProfilerMiddleware
+
+        from rustfava.util import setup_debug_logging
+
+        setup_debug_logging()
+        if profile:
+            app.wsgi_app = ProfilerMiddleware(  # type: ignore[method-assign]
+                app.wsgi_app,
+                restrictions=(30,),
+                profile_dir=profile_dir or None,
+            )
+
+        app.jinja_env.auto_reload = True
+        try:
+            app.run(host, port, debug)
+        except OSError as error:
+            if error.errno == errno.EADDRINUSE:
+                raise AddressInUse(port) from error
+            raise
+
+
+# needed for pyinstaller:
+if __name__ == "__main__":  # pragma: no cover
+    main()

rustfava/context.py

@@ -0,0 +1,13 @@
+"""Specify types for the flask application context."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from flask import g as flask_g
+
+if TYPE_CHECKING:  # pragma: no cover
+    from rustfava._ctx_globals_class import Context
+
+
+g: Context = flask_g  # type: ignore[assignment]