beancount-format 0.0.1__tar.gz

beancount_format-0.0.1/.gitignore

@@ -0,0 +1,116 @@
+node_modules/
+.task/
+
+# Created by .ignore support plugin (hsz.mobi)
+### Python template
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+docs/source/_build/
+docs/build/
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+pip-wheel-metadata
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+.hypothesis/
+.pytest_cache/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# pyenv
+.python-version
+
+# celery beat schedule file
+celerybeat-schedule
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+
+# IDE
+.vscode/
+.idea/
+main.py

beancount_format-0.0.1/.pre-commit-config.yaml

@@ -0,0 +1,41 @@
+default_stages: [commit]
+
+repos:
+  - repo: https://github.com/abravalheri/validate-pyproject
+    rev: v0.19
+    hooks:
+      - id: validate-pyproject
+        # Optional extra validations from SchemaStore:
+        additional_dependencies: [ "validate-pyproject-schema-store[all]" ]
+
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v4.6.0
+    hooks:
+      - id: check-case-conflict
+      - id: check-ast
+      - id: check-builtin-literals
+      - id: check-toml
+      - id: check-yaml
+      - id: check-json
+      - id: check-docstring-first
+      - id: check-merge-conflict
+      - id: check-added-large-files # check for file bigger than 500kb
+      - id: debug-statements
+      - id: trailing-whitespace
+      - id: mixed-line-ending
+        args: [--fix=lf]
+      - id: end-of-file-fixer
+      - id: fix-byte-order-marker
+      - id: fix-encoding-pragma
+        args: [--remove]
+
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: v0.6.9
+    hooks:
+      - id: ruff
+        args: [ --fix ]
+
+  - repo: https://github.com/psf/black
+    rev: 24.8.0
+    hooks:
+      - id: black

beancount_format-0.0.1/.pre-commit-hooks.yaml

@@ -0,0 +1,7 @@
+- id: beancount-format
+  name: beancount-format
+  description: format beancount code
+  entry: beancount-format
+  language: python
+  pass_filenames: true
+  files: ^.*.bean$

beancount_format-0.0.1/LICENSE

@@ -0,0 +1,24 @@
+MIT License
+
+Copyright (c) 2023 Trim21 <trim21me@gmail.com>
+
+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.

beancount_format-0.0.1/PKG-INFO

@@ -0,0 +1,33 @@
+Metadata-Version: 2.1
+Name: beancount-format
+Version: 0.0.1
+Summary: Typed rtorrent rpc client
+Keywords: rtorrent,rpc
+Author-email: trim21 <trim21me@gmail.com>
+Requires-Python: ~=3.9
+Description-Content-Type: text/markdown
+Classifier: Intended Audience :: Developers
+Classifier: Development Status :: 4 - Beta
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3 :: Only
+Requires-Dist: beancount-parser==1.2.3
+Requires-Dist: click~=8.0
+Requires-Dist: pytest==8.3.2 ; extra == "dev"
+Requires-Dist: pytest-github-actions-annotate-failures==0.2.0 ; extra == "dev"
+Requires-Dist: coverage==7.6.1 ; extra == "dev"
+Requires-Dist: pre-commit==3.8.0 ; extra == "dev" and ( python_version >= "3.9")
+Requires-Dist: mypy==1.13.0 ; extra == "dev" and ( python_version >= "3.9")
+Project-URL: Homepage, https://github.com/trim21/beancount-format
+Provides-Extra: dev
+
+format beancount
+
+as pre-commit hooks
+
+```yaml
+repos:
+  - repo: https://github.com/trim21/beancount-format
+    rev: 801ab26
+    hooks:
+      - id: beancount-format
+```

beancount_format-0.0.1/beancount_format/__main__.py

@@ -0,0 +1,4 @@
+from beancount_format.cli import main
+
+if __name__ == "__main__":
+    main()

beancount_format-0.0.1/beancount_format/cli.py

@@ -0,0 +1,48 @@
+import io
+import pathlib
+import sys
+from collections.abc import Generator, Sequence
+
+import click
+from beancount_parser.parser import make_parser
+
+from beancount_format.format import Formatter
+
+
+def __input_files(paths: Sequence[pathlib.Path]) -> Generator[pathlib.Path, None, None]:
+    for p in paths:
+        if p.is_file():
+            yield p
+        else:
+            yield from __input_files(p.iterdir())
+
+
+@click.command
+@click.argument("path", nargs=-1, type=click.Path(path_type=pathlib.Path))
+@click.option("--indent", default=4, type=int)
+def main(path, indent: int):
+    parser = make_parser()
+    formatter = Formatter(indent_width=indent)
+
+    exit_code = 0
+
+    for file in __input_files(path):
+        if file.suffix.lower() not in {".bean"}:
+            continue
+        try:
+            input_content = file.read_text(encoding="utf-8")
+            tree = parser.parse(input_content)
+            output_file = io.StringIO()
+            with output_file:
+                formatter.format(tree, output_file)
+                formatted = output_file.getvalue()
+            if input_content == formatted:
+                continue
+            print("formatting", file)
+            file.write_bytes(formatted.encode("utf-8"))
+            exit_code = 1
+        except Exception as e:
+            print("failed to format file", file, e)
+            return 1
+
+    return sys.exit(exit_code)

beancount_format-0.0.1/beancount_format/format.py

@@ -0,0 +1,664 @@
+import datetime
+import decimal
+import enum
+import io
+import logging
+import re
+import typing
+
+from lark import ParseTree, Token, Tree
+
+VERBOSE_LOG_LEVEL = logging.NOTSET + 1
+
+COMMENT_PREFIX = re.compile("[;*]+")
+DEFAULT_INDENT_WIDTH = 2
+DEFAULT_ACCOUNT_WIDTH = 30
+DEFAULT_NUMBER_WIDTH = 12
+# the difference of column width we need to make up for balance account field,
+# so a balance statement starts with
+#
+#   "2022-01-01 balance "
+#
+BALANCE_PREFIX_WIDTH = 19
+
+
+@enum.unique
+class EntryType(enum.Enum):
+    # Date directives
+    OPEN = "OPEN"
+    CLOSE = "CLOSE"
+    BALANCE = "BALANCE"
+    EVENT = "EVENT"
+    COMMODITY = "COMMODITY"
+    DOCUMENT = "DOCUMENT"
+    PRICE = "PRICE"
+    NOTE = "NOTE"
+    PAD = "PAD"
+    CUSTOM = "CUSTOM"
+    TXN = "TXN"
+    # Simple directives
+    OPTION = "OPTION"
+    INCLUDE = "INCLUDE"
+    PLUGIN = "PLUGIN"
+    # Other
+    COMMENTS = "COMMENTS"
+
+
+# The entries which are going to be listed in groups before all other entries
+LEADING_ENTRY_TYPES: typing.List[EntryType] = [
+    EntryType.COMMENTS,
+    EntryType.INCLUDE,
+    EntryType.PLUGIN,
+    EntryType.OPTION,
+    EntryType.COMMODITY,
+    EntryType.OPEN,
+    EntryType.CLOSE,
+]
+
+DATE_DIRECTIVE_ENTRY_TYPES = {
+    "open": EntryType.OPEN,
+    "close": EntryType.CLOSE,
+    "balance": EntryType.BALANCE,
+    "event": EntryType.EVENT,
+    "commodity": EntryType.COMMODITY,
+    "document": EntryType.DOCUMENT,
+    "price": EntryType.PRICE,
+    "note": EntryType.NOTE,
+    "pad": EntryType.PAD,
+    "custom": EntryType.CUSTOM,
+    "txn": EntryType.TXN,
+}
+
+SIMPLE_DIRECTIVE_ENTRY_TYPES = {
+    "option": EntryType.OPTION,
+    "include": EntryType.INCLUDE,
+    "plugin": EntryType.PLUGIN,
+}
+
+
+def get_entry_type(statement: Tree) -> EntryType:
+    first_child: Tree = statement.children[0]
+    if first_child.data == "date_directive":
+        return DATE_DIRECTIVE_ENTRY_TYPES[first_child.children[0].data.value]
+    if first_child.data == "simple_directive":
+        return SIMPLE_DIRECTIVE_ENTRY_TYPES[first_child.children[0].data.value]
+    raise ValueError(f"Unexpected first child type {first_child.data}")
+
+
+class StatementGroup(typing.NamedTuple):
+    section_header: typing.Optional[Token]
+    statements: typing.List[Tree]
+
+
+class Metadata(typing.NamedTuple):
+    comments: typing.List[Token]
+    statement: Tree
+
+
+class Posting(typing.NamedTuple):
+    comments: typing.List[Token]
+    statement: Tree
+    metadata: typing.List[Metadata]
+
+
+class Entry(typing.NamedTuple):
+    type: EntryType
+    comments: typing.List[Token]
+    statement: Tree
+    metadata: typing.List[Metadata]
+    postings: typing.List[Posting]
+
+
+def parse_date(date_str: str) -> datetime.date:
+    parts = date_str.split("-")
+    return datetime.date(*(map(int, parts)))
+
+
+class Collector:
+    def __init__(self, logger: typing.Optional[logging.Logger] = None):
+        super().__init__()
+        self.logger = logger or logging.getLogger(__name__)
+        # Collection of the header comments
+        self.header_comments: typing.List[Token] = []
+        self.statement_groups: typing.List[StatementGroup] = []
+
+    def collect(self, tree: Tree):
+        self.logger.info("Collecting")
+        if tree.data != "start":
+            raise ValueError("Expected start")
+        for child in tree.children:
+            if child is None:
+                continue
+            self.statement(child)
+
+    def statement(self, tree: Tree):
+        if tree.data != "statement":
+            raise ValueError("Expected statement")
+        self.logger.debug("Collecting statement at line %s", tree.meta.line)
+        first_child = tree.children[0]
+        if isinstance(first_child, Token):
+            # Comment only line
+            if first_child.type == "COMMENT":
+                if self.comment_token(first_child):
+                    # already added as part of the header comments, just return
+                    return
+            elif first_child.type == "SECTION_HEADER":
+                self.section_header_token(first_child)
+                return
+            else:
+                raise ValueError("Unexpected token type %s", first_child.type)
+        if not self.statement_groups:
+            self.statement_groups.append(
+                StatementGroup(section_header=None, statements=[])
+            )
+        self.statement_groups[-1].statements.append(tree)
+
+    def section_header_token(self, token: Token):
+        self.logger.debug(
+            "New statement group for %r at line %s", token.value, token.line
+        )
+        self.statement_groups.append(
+            StatementGroup(section_header=token, statements=[])
+        )
+
+    def comment_token(self, token: Token) -> bool:
+        if token.line != len(self.header_comments) + 1:
+            return False
+        if self.statement_groups:
+            return False
+        self.logger.debug("Collect header comment %s at line %s", token, token.line)
+        self.header_comments.append(token)
+        return True
+
+
+def chunks(lst, n):
+    """Yield successive n-sized chunks from lst."""
+    for i in range(0, len(lst), n):
+        yield lst[i : i + n]
+
+
+def format_number(d: decimal.Decimal, n: int = 3):
+    ss = str(d)
+
+    a, _, b = ss.partition(".")
+
+    parts = []
+
+    for part in chunks(a[::-1], n):
+        parts.append("".join(reversed(part)))
+
+    parts.reverse()
+
+    a = ",".join(parts)
+
+    if b:
+        return a + "." + b
+
+    return a
+
+
+class Formatter:
+    def __init__(
+        self,
+        indent_width: int = DEFAULT_INDENT_WIDTH,
+        min_account_width: int = DEFAULT_ACCOUNT_WIDTH,
+        min_number_width: int = DEFAULT_NUMBER_WIDTH,
+        # num_sep_width: int = 3,
+        logger: typing.Optional[logging.Logger] = None,
+    ):
+        self.indent_width: int = indent_width
+        self.account_width: int = min_account_width
+        self.number_width: int = min_number_width
+        # self.num_sep_width: int = num_sep_width
+        self.logger = logger or logging.getLogger(__name__)
+
+    def format_comment(self, token: Token) -> str:
+        value = token.value.strip()
+        match = COMMENT_PREFIX.match(value)
+        prefix = match.group(0)
+        remain = value[len(prefix) :].strip()
+        if not remain:
+            return prefix
+        return f"{prefix} {remain}"
+
+    def format_number(self, token: Token) -> str:
+        if token.type != "NUMBER":
+            raise ValueError("Expected a NUMBER")
+        value = token.value.replace(",", "")
+
+        return str(decimal.Decimal(value))
+
+    def format_number_atom(self, tree_or_token: typing.Union[Tree, Token]) -> str:
+        if isinstance(tree_or_token, Token):
+            token: Token = tree_or_token
+            if token.type == "NUMBER":
+                return self.format_number(token)
+            raise ValueError(f"Unknown token type {token.type}")
+        if isinstance(tree_or_token, Tree):
+            tree: Tree = tree_or_token
+            if tree.data == "number_atom":
+                unary_op, number_atom = tree.children
+                if unary_op.type != "UNARY_OP":
+                    raise ValueError(f"Expected to be UNARY_OP but got {unary_op.data}")
+                return unary_op.value + self.format_number_atom(number_atom)
+            if tree.data == "number_mul_expr":
+                return self.format_number_mul_expr(tree)
+            if tree.data == "number_add_expr":
+                return self.format_number_add_expr(tree)
+            raise ValueError(f"Unknown tree {tree.data}")
+        raise ValueError(f"Unexpected type {type(tree_or_token)}")
+
+    def format_number_mul_expr(self, tree: Tree) -> str:
+        if tree.data != "number_mul_expr":
+            raise ValueError("Expected a number_mul_expr")
+        items: typing.List[str] = []
+        for child in tree.children:
+            if isinstance(child, Token):
+                if child.type == "MUL_OP":
+                    items.append(f" {child.value} ")
+                else:
+                    items.append(self.format_number_atom(child))
+            else:
+                items.append(self.format_number_atom(child))
+        return f'({"".join(items)})'
+
+    def format_number_add_expr(self, tree: Tree) -> str:
+        if tree.data != "number_add_expr":
+            raise ValueError("Expected a number_add_expr")
+        items: typing.List[str] = []
+        for child in tree.children:
+            if isinstance(child, Token):
+                if child.type == "ADD_OP":
+                    items.append(f" {child.value} ")
+                else:
+                    items.append(self.format_number_atom(child))
+            elif isinstance(child, Tree) and child.data == "number_atom":
+                items.append(self.format_number_atom(child))
+            else:
+                items.append(self.format_number_mul_expr(child))
+        return f'({"".join(items)})'
+
+    def format_number_expr(self, tree: Tree) -> str:
+        if tree.data != "number_expr":
+            raise ValueError("Expected a number_expr")
+        first_child: typing.Union[Tree, Token] = tree.children[0]
+        if isinstance(first_child, Tree) and first_child.data == "number_add_expr":
+            return self.format_number_add_expr(first_child)
+        return self.format_number_atom(first_child)
+
+    def get_amount_columns(self, tree: Tree) -> typing.List[str]:
+        if tree.data != "amount":
+            raise ValueError("Expected a amount")
+        number, currency = tree.children
+        return [self.format_number_expr(number), currency.value]
+
+    def get_amount_tolerance_columns(self, tree: Tree) -> typing.List[str]:
+        if tree.data != "amount_tolerance":
+            raise ValueError("Expected a amount")
+        number, tolerance, currency = tree.children
+        return [
+            self.format_number_expr(number),
+            "~",
+            self.format_number_expr(tolerance),
+            currency.value,
+        ]
+
+    def format_price(self, tree: Tree) -> str:
+        if tree.data not in {"per_unit_price", "total_price"}:
+            raise ValueError("Expected a per_unit_price or total_price")
+        amount = tree.children[0]
+        amount_value = " ".join(self.get_amount_columns(amount))
+        if tree.data == "per_unit_price":
+            prefix = "@"
+        elif tree.data == "total_price":
+            prefix = "@@"
+        else:
+            raise ValueError
+        return " ".join([prefix, amount_value])
+
+    def format_cost_item(self, tree: Tree) -> str:
+        if tree.data != "cost_item":
+            raise ValueError("Expected a cost_item")
+        child = tree.children[0]
+        if isinstance(child, Token) and child.type in {
+            "DATE",
+            "ESCAPED_STRING",
+            "ASTERISK",
+        }:
+            return child.value
+        if child.data == "amount":
+            return " ".join(self.get_amount_columns(child))
+        raise ValueError(f"Unexpected cost item {tree}")
+
+    def format_cost(self, tree: Tree) -> str:
+        if tree.data in {"per_unit_cost", "dated_cost"}:
+            raise RuntimeError(
+                "You are using an out-dated beancount-parser, version >= 1.0.0 is required"
+            )
+        if tree.data not in {"total_cost", "both_cost", "cost_spec"}:
+            raise ValueError("Expected a total_cost, both_cost or cost_spec")
+        if tree.data != "total_cost":
+            bracket_start = "{"
+            bracket_end = "}"
+        else:
+            bracket_start = "{{"
+            bracket_end = "}}"
+        separator = " "
+        items: typing.List[str] = []
+        if tree.data == "total_cost":
+            amount = tree.children[0]
+            amount_value = " ".join(self.get_amount_columns(amount))
+            items.append(amount_value)
+        if tree.data == "both_cost":
+            number, amount = tree.children
+            number_value = self.format_number_expr(number)
+            amount_value = " ".join(self.get_amount_columns(amount))
+            items.append(number_value)
+            items.append("#")
+            items.append(amount_value)
+        elif tree.data == "cost_spec":
+            separator = ", "
+            items.extend(map(self.format_cost_item, tree.children))
+        return bracket_start + separator.join(items) + bracket_end
+
+    def get_directive_child_columns(
+        self, child: typing.Union[Token, Tree]
+    ) -> typing.List[str]:
+        if isinstance(child, Token):
+            # TODO: some token may need reformat?
+            return [child.value]
+        tree: Tree = child
+        if tree.data == "currencies":
+            return [",".join(currency.value for currency in tree.children)]
+        if tree.data == "amount":
+            return self.get_amount_columns(tree)
+        if tree.data == "amount_tolerance":
+            return self.get_amount_tolerance_columns(tree)
+        if tree.data == "number_expr":
+            return [self.format_number_expr(tree)]
+        raise ValueError(f"Unknown tree type {tree.data}")
+
+    def format_metadata_item_value(
+        self, tree_or_token: typing.Union[Tree, Token]
+    ) -> str:
+        if isinstance(tree_or_token, Token):
+            token: Token = tree_or_token
+            if token.type in {"ESCAPED_STRING", "ACCOUNT", "CURRENCY", "DATE", "TAGS"}:
+                return token.value
+            raise ValueError(f"Unknown token type {token.type}")
+        if isinstance(tree_or_token, Tree):
+            tree: Tree = tree_or_token
+            if tree.data == "number_expr":
+                return self.format_number_expr(tree)
+            if tree.data == "amount":
+                return " ".join(self.get_amount_columns(tree))
+            raise ValueError(f"Unknown tree {tree.data}")
+        raise ValueError(f"Unexpected type {type(tree_or_token)}")
+
+    def format_metadata_item(self, tree: Tree) -> str:
+        if tree.data != "metadata_item":
+            raise ValueError("Expected a metadata item")
+        key_token, value_tree_or_token = tree.children
+        return (
+            f"{key_token.value}: {self.format_metadata_item_value(value_tree_or_token)}"
+        )
+
+    def format_simple_directive(self, tree: Tree) -> str:
+        if tree.data != "simple_directive":
+            raise ValueError("Expected a simple directive")
+        first_child = tree.children[0]
+        items: typing.List[str] = [first_child.data.value] + [
+            child.value for child in first_child.children if child is not None
+        ]
+        return " ".join(items)
+
+    def format_date_directive(self, tree: Tree) -> str:
+        if tree.data != "date_directive":
+            raise ValueError("Expected a date directive")
+        first_child = tree.children[0]
+        date = first_child.children[0].value
+        directive_type = first_child.data.value
+        if directive_type == "txn":
+            columns: typing.List[str] = [date]
+            flag, payee, narration, annotations = first_child.children[1:]
+            if flag is not None:
+                columns.append(flag.value)
+            if payee is not None:
+                columns.append(payee.value)
+            if narration is not None:
+                columns.append(narration.value)
+            if annotations is not None:
+                annotation_values = [
+                    annotation.value for annotation in annotations.children
+                ]
+                links = list(filter(lambda v: v.startswith("^"), annotation_values))
+                links.sort()
+                hashes = list(filter(lambda v: v.startswith("#"), annotation_values))
+                hashes.sort()
+                columns.extend(links)
+                columns.extend(hashes)
+            return " ".join(columns)
+        columns: typing.List[str] = [date, directive_type]
+        for child in first_child.children[1:]:
+            if child is None:
+                continue
+            columns.extend(self.get_directive_child_columns(child))
+        if directive_type == "balance":
+            for index, column in enumerate(columns):
+                prefix = ""
+                # account
+                if index == 2:
+                    width = self.account_width
+                # number
+                elif index == 3:
+                    width = self.number_width
+                    prefix = ">"
+                else:
+                    continue
+                new_value = f"{column:{prefix}{width}}"
+                columns[index] = new_value
+        return " ".join(columns)
+
+    def format_posting(self, tree: Tree) -> str:
+        if tree.data != "posting":
+            raise ValueError("Expected a posting")
+        # Simple posting
+        flag: Token
+        account: Token
+        amount: typing.Optional[Tree] = None
+        cost: typing.Optional[Tree] = None
+        price: typing.Optional[Tree] = None
+        if tree.children[0].data == "detailed_posting":
+            flag, account, amount, cost, price = tree.children[0].children
+        else:
+            flag, account = tree.children[0].children
+        items: typing.List[str] = []
+        if flag is not None:
+            items.append(flag.value)
+        account_value = account.value
+        # only need to apply width when it's not short posting format
+        if amount is not None:
+            # Need to add the difference for balance prefix width
+            width = self.account_width + (BALANCE_PREFIX_WIDTH - self.indent_width)
+            account_value = f"{account_value:{width}}"
+        items.append(account_value)
+        if amount is not None:
+            number, currency = self.get_amount_columns(amount)
+            items.append(f"{number:>{self.number_width}}")
+            items.append(currency)
+        if cost is not None:
+            items.append(self.format_cost(cost))
+        if price is not None:
+            items.append(self.format_price(price))
+        return " ".join(items)
+
+    def format_metadata_lines(
+        self, metadata_list: typing.List[Metadata]
+    ) -> typing.List[str]:
+        lines: typing.List[str] = []
+        for metadata in metadata_list:
+            for comment in metadata.comments:
+                lines.append(self.format_comment(comment))
+            line = self.format_metadata_item(metadata.statement.children[0])
+            tail_comment = metadata.statement.children[1]
+            if tail_comment is not None:
+                line += " " + self.format_comment(tail_comment)
+            lines.append(line)
+        return lines
+
+    def format_posting_lines(
+        self,
+        postings: typing.List[Posting],
+    ) -> typing.List[str]:
+        lines: typing.List[str] = []
+        for posting in postings:
+            for comment in posting.comments:
+                lines.append(self.format_comment(comment))
+            line = self.format_posting(posting.statement.children[0])
+            tail_comment = posting.statement.children[1]
+            if tail_comment is not None:
+                line += " " + self.format_comment(tail_comment)
+            lines.append(line)
+            metadata_lines = self.format_metadata_lines(posting.metadata)
+            for metadata_line in metadata_lines:
+                lines.append(" " * self.indent_width + metadata_line)
+        return lines
+
+    def format_entry(self, entry: Entry) -> str:
+        self.logger.debug(
+            "Format entry type %s at line %s",
+            entry.type.value,
+            entry.statement.meta.line,
+        )
+        self.logger.log(VERBOSE_LOG_LEVEL, "Entry value %s", entry)
+        lines = []
+        for comment in entry.comments:
+            lines.append(self.format_comment(comment))
+
+        if entry.type != EntryType.COMMENTS:
+            first_child = entry.statement.children[0]
+            if first_child.data == "date_directive":
+                line = self.format_date_directive(first_child)
+                tail_comment = entry.statement.children[1]
+                if tail_comment is not None:
+                    line += " " + self.format_comment(tail_comment)
+                lines.append(line)
+                metadata_lines = self.format_metadata_lines(entry.metadata)
+                for metadata_line in metadata_lines:
+                    lines.append(" " * self.indent_width + metadata_line)
+                posting_lines = self.format_posting_lines(entry.postings)
+                for posting_line in posting_lines:
+                    lines.append(" " * self.indent_width + posting_line)
+            else:
+                line = self.format_simple_directive(first_child)
+                tail_comment = entry.statement.children[1]
+                if tail_comment is not None:
+                    line += " " + self.format_comment(tail_comment)
+                lines.append(line)
+        return "\n".join(lines)
+
+    def format_statement_group(self, group: StatementGroup) -> str:
+        sections: typing.List[str] = []
+        if group.section_header is not None:
+            sections.append(self.format_comment(group.section_header))
+
+        entries: typing.List[Entry] = []
+        comments: typing.List[Token] = []
+        for statement in group.statements:
+            first_child = statement.children[0]
+            if isinstance(first_child, Token):
+                if first_child.type == "COMMENT":
+                    comments.append(first_child)
+                else:
+                    raise ValueError(f"Unexpected token {first_child.type}")
+            else:
+                if first_child.data == "posting":
+                    last_entry = entries[-1]
+                    if last_entry.type != EntryType.TXN:
+                        raise ValueError("Transaction expected")
+                    last_entry.postings.append(
+                        Posting(comments=comments, statement=statement, metadata=[])
+                    )
+                    comments = []
+                    continue
+                if first_child.data == "metadata_item":
+                    last_entry = entries[-1]
+                    metadata = Metadata(comments=comments, statement=statement)
+                    if last_entry.postings:
+                        last_posting: Posting = last_entry.postings[-1]
+                        last_posting.metadata.append(metadata)
+                    else:
+                        last_entry.metadata.append(metadata)
+                    comments = []
+                    continue
+                entry = Entry(
+                    type=get_entry_type(statement),
+                    comments=comments,
+                    statement=statement,
+                    metadata=[],
+                    postings=[],
+                )
+                entries.append(entry)
+                comments = []
+
+        for entry in entries:
+            sections.append(self.format_entry(entry))
+
+        return "\n\n".join(sections)
+
+    def calculate_column_widths(self, tree: ParseTree):
+        self.logger.info("Calculate column width")
+        for statement in tree.children:
+            if statement is None:
+                continue
+            self.logger.debug(
+                "Calculate column width for statement at line %s", statement.meta.line
+            )
+            self.logger.log(VERBOSE_LOG_LEVEL, "Statement %s", statement)
+            first_child = statement.children[0]
+            if isinstance(first_child, Token):
+                continue
+            account: typing.Optional[Token] = None
+            amount: typing.Optional[Tree] = None
+            if first_child.data == "posting":
+                # Simple posting
+                if first_child.children[0].data == "detailed_posting":
+                    _, account, amount, *_ = first_child.children[0].children
+                else:
+                    _, account = first_child.children[0].children
+            elif (
+                first_child.data == "date_directive"
+                and first_child.children[0].data == "balance"
+            ):
+                _, account, amount = first_child.children[0].children
+            if account is not None and len(account.value) > self.account_width:
+                # bump account width
+                self.account_width = len(account.value)
+            if amount is not None:
+                width = len(self.format_number_expr(amount.children[0]))
+                self.number_width = max(width, self.number_width)
+
+    def format(self, tree: ParseTree, output_file: io.TextIOBase):
+        if tree.data != "start":
+            raise ValueError("expected start as the root rule")
+        self.calculate_column_widths(tree)
+
+        collector = Collector()
+        collector.collect(tree)
+
+        # write header comments
+        sections: typing.List[str] = []
+        if collector.header_comments:
+            lines: typing.List[str] = [
+                self.format_comment(header_comment)
+                for header_comment in collector.header_comments
+            ]
+            sections.append("\n".join(lines))
+
+        for group in collector.statement_groups:
+            # Console(emoji=False).print(group)
+            sections.append(self.format_statement_group(group))
+
+        output_file.write("\n\n".join(sections))
+        if sections:
+            output_file.write("\n")

beancount_format-0.0.1/pyproject.toml

@@ -0,0 +1,128 @@
+[build-system]
+requires = ["flit-core~=3.9"]
+build-backend = "flit_core.buildapi"
+
+[project]
+name = "beancount-format"
+version = "0.0.1"
+description = "Typed rtorrent rpc client"
+authors = [
+    { name = "trim21", email = "trim21me@gmail.com" },
+]
+readme = 'readme.md'
+license = { text = 'MIT' }
+keywords = ['rtorrent', 'rpc']
+classifiers = [
+    'Intended Audience :: Developers',
+    'Development Status :: 4 - Beta',
+    'License :: OSI Approved :: MIT License',
+    'Programming Language :: Python :: 3 :: Only',
+]
+
+requires-python = "~=3.9"
+
+dependencies = [
+    'beancount-parser==1.2.3',
+    'click~=8.0',
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest==8.3.2",
+    "pytest-github-actions-annotate-failures==0.2.0",
+    "coverage==7.6.1",
+    'pre-commit==3.8.0; python_version >= "3.9"',
+    'mypy==1.13.0; python_version >= "3.9"',
+]
+
+[project.urls]
+Homepage = "https://github.com/trim21/beancount-format"
+
+[project.scripts]
+beancount-format = "beancount_format.cli:main"
+
+[tool.pytest.ini_options]
+addopts = '-rav -Werror'
+
+[tool.mypy]
+python_version = "3.8"
+disallow_untyped_defs = true
+ignore_missing_imports = true
+warn_return_any = false
+warn_unused_configs = true
+show_error_codes = true
+
+platform = 'unix'
+
+[tool.black]
+target-version = ['py38']
+
+[tool.ruff]
+target-version = "py38"
+
+[tool.ruff.lint]
+select = [
+    "B",
+    "C",
+    "E",
+    "F",
+    "G",
+    "I",
+    "N",
+    "Q",
+    "S",
+    "W",
+    "BLE",
+    "EXE",
+    "ICN",
+    "INP",
+    "ISC",
+    "NPY",
+    "PD",
+    "PGH",
+    "PIE",
+    "PL",
+    "PT",
+    "PYI",
+    "RET",
+    "RSE",
+    "RUF",
+    "SIM",
+    "SLF",
+    "TCH",
+    "TID",
+    "TRY",
+    "YTT",
+]
+
+ignore = [
+    'PLR0911',
+    'INP001',
+    'N806',
+    'N802',
+    'N803',
+    'E501',
+    'BLE001',
+    'RUF002',
+    'S324',
+    'S301',
+    'S314',
+    'S101',
+    'N815',
+    'S104',
+    'C901',
+    'PLR0913',
+    'RUF001',
+    'SIM108',
+    'TCH003',
+    'RUF003',
+    'RET504',
+    'TRY300',
+    'TRY003',
+    'TRY201',
+    'TRY301',
+    'PLR0912',
+    'PLR0915',
+    'PLR2004',
+    'PGH003',
+]

beancount_format-0.0.1/readme.md

@@ -0,0 +1,11 @@
+format beancount
+
+as pre-commit hooks
+
+```yaml
+repos:
+  - repo: https://github.com/trim21/beancount-format
+    rev: 801ab26
+    hooks:
+      - id: beancount-format
+```

beancount_format-0.0.1/taskfile.yaml

@@ -0,0 +1,25 @@
+version: 3
+
+tasks:
+  default:
+    - black .
+    - ruff check . --fix
+
+  minor:
+    cmds:
+      - pyproject-bump minor
+      - task: bump
+
+  patch:
+    cmds:
+      - pyproject-bump micro
+      - task: bump
+
+  bump:
+    vars:
+      VERSION:
+        sh: yq '.project.version' pyproject.toml
+    cmds:
+      - git add pyproject.toml
+      - 'git commit -m "bump: {{.VERSION}}"'
+      - 'git tag "v{{.VERSION}}" -m "v{{.VERSION}}"'