moneymanager-parser 0.1.0__py3-none-any.whl

moneymanager_parser/__init__.py

@@ -0,0 +1,15 @@
+"""Typed SDK for Realbyte Money Manager backup files."""
+
+from .core import MoneyManagerBackup
+from .models import Account, Currency, QueryResult, Transaction
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "Account",
+    "Currency",
+    "MoneyManagerBackup",
+    "QueryResult",
+    "Transaction",
+    "__version__",
+]

moneymanager_parser/cli.py

@@ -0,0 +1,86 @@
+"""Command line interface for moneymanager-parser."""
+
+from __future__ import annotations
+
+import argparse
+import json
+from collections.abc import Sequence
+from typing import Any
+
+from .core import MoneyManagerBackup
+from .models import Currency
+
+
+def _print(data: Any) -> None:
+    print(json.dumps(data, indent=2, default=str))
+
+
+def _currency_dict(currency: Currency | None) -> dict[str, Any] | None:
+    if currency is None:
+        return None
+    return {
+        "iso": currency.iso,
+        "symbol": currency.symbol,
+        "name": currency.name,
+        "is_main": currency.is_main,
+    }
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(prog="mmbak", description="Offline Realbyte .mmbak parser")
+    sub = parser.add_subparsers(dest="command", required=True)
+    for name in ("schema", "currency"):
+        cmd = sub.add_parser(name)
+        cmd.add_argument("path")
+    query = sub.add_parser("query")
+    query.add_argument("path")
+    query.add_argument("--from", dest="date_from")
+    query.add_argument("--to", dest="date_to")
+    query.add_argument("--month")
+    query.add_argument("--category")
+    query.add_argument("--search")
+    query.add_argument("--kind", choices=["expense", "income", "all"], default="expense")
+    query.add_argument("--group-by", choices=["month", "category", "day", "week"])
+    query.add_argument("--top", type=int)
+    query.add_argument("--list", dest="list_n", type=int)
+    query.add_argument("--limit", type=int, default=24)
+    return parser
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    args = build_parser().parse_args(argv)
+    try:
+        with MoneyManagerBackup.from_file(args.path) as backup:
+            if args.command == "schema":
+                _print(backup.schema())
+            elif args.command == "currency":
+                main_currency = backup.currency()
+                _print(
+                    {
+                        "main": _currency_dict(main_currency),
+                        "all": [_currency_dict(item) for item in backup.currencies()],
+                    }
+                )
+            else:
+                _print(
+                    backup.query(
+                        date_from=args.date_from,
+                        date_to=args.date_to,
+                        month=args.month,
+                        category=args.category,
+                        search=args.search,
+                        kind=args.kind,
+                        group_by=args.group_by,
+                        top=args.top,
+                        list_n=args.list_n,
+                        limit=args.limit,
+                    ).as_dict()
+                )
+    except Exception as exc:  # noqa: BLE001
+        _print({"status": "error", "reason": str(exc)})
+        return 1
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

moneymanager_parser/core.py

@@ -0,0 +1,559 @@
+"""Core parser for Realbyte Money Manager backup files."""
+
+from __future__ import annotations
+
+import calendar
+import io
+import os
+import sqlite3
+import tempfile
+import zipfile
+from collections.abc import Iterable, Iterator, Mapping
+from dataclasses import dataclass
+from datetime import date, datetime, timedelta
+from pathlib import Path
+from typing import Any, cast
+
+from .models import (
+    Account,
+    Currency,
+    GroupBy,
+    JsonDict,
+    Kind,
+    QueryKind,
+    QueryResult,
+    Transaction,
+)
+from .schema import (
+    AMOUNT_COLS,
+    ASSET_TABLE_CANDIDATES,
+    ASSETFK_COLS,
+    BALANCE_COLS,
+    CATEGORY_TABLE_CANDIDATES,
+    CATFK_COLS,
+    CATNAME_COLS,
+    CURRENCY_ISO_COLS,
+    CURRENCY_MAIN_COLS,
+    CURRENCY_SYMBOL_COLS,
+    CURRENCY_TABLE_CANDIDATES,
+    DATE_COLS,
+    DEFAULT_TYPE_MAP,
+    MEMO_COLS,
+    NAME_COLS,
+    STRING_TYPE_MAP,
+    TXN_TABLE_CANDIDATES,
+    TYPE_COLS,
+    UID_COLS,
+)
+
+TypeMap = Mapping[int, Kind]
+
+
+def _first_present(options: Iterable[str], available: Iterable[str]) -> str | None:
+    aset = set(available)
+    for option in options:
+        if option in aset:
+            return option
+    lower = {item.lower(): item for item in available}
+    for option in options:
+        found = lower.get(option.lower())
+        if found is not None:
+            return found
+    return None
+
+
+def _table_columns(con: sqlite3.Connection, table: str) -> list[str]:
+    return [str(row[1]) for row in con.execute(f'PRAGMA table_info("{table}")')]
+
+
+def _list_tables(con: sqlite3.Connection) -> list[str]:
+    return [str(row[0]) for row in con.execute("SELECT name FROM sqlite_master WHERE type='table'")]
+
+
+def _pick_table(
+    _con: sqlite3.Connection, candidates: Iterable[str], tables: Iterable[str]
+) -> str | None:
+    return _first_present(candidates, tables)
+
+
+def _parse_date(value: object) -> date | None:
+    if value is None:
+        return None
+    if isinstance(value, (int, float)):
+        number = float(value)
+        if number > 1e12:
+            return datetime.fromtimestamp(number / 1000).date()
+        if number > 1e9:
+            return datetime.fromtimestamp(number).date()
+        return None
+    text = str(value).strip()
+    if not text:
+        return None
+    if text.lstrip("-").isdigit():
+        number = int(text)
+        if len(text) >= 12:
+            return datetime.fromtimestamp(number / 1000).date()
+        if len(text) in {10, 11}:
+            return datetime.fromtimestamp(number).date()
+    for fmt in ("%Y-%m-%d %H:%M:%S", "%Y-%m-%d", "%Y/%m/%d %H:%M:%S", "%Y/%m/%d"):
+        try:
+            return datetime.strptime(text, fmt).date()
+        except ValueError:
+            continue
+    digits = "".join(char for char in text if char.isdigit())
+    if len(digits) >= 8:
+        try:
+            return date(int(digits[0:4]), int(digits[4:6]), int(digits[6:8]))
+        except ValueError:
+            return None
+    return None
+
+
+def _to_float(value: object) -> float:
+    try:
+        return float(cast(Any, value))
+    except (TypeError, ValueError):
+        return 0.0
+
+
+def _normal_type_map(type_map: Mapping[int, str] | None) -> dict[int, Kind]:
+    source = type_map or DEFAULT_TYPE_MAP
+    out: dict[int, Kind] = {}
+    for key, value in source.items():
+        if value not in {"income", "expense", "transfer"}:
+            raise ValueError(f"unsupported transaction kind: {value}")
+        out[int(key)] = cast(Kind, value)
+    return out
+
+
+def _kind(do_type: object, type_map: Mapping[int, Kind]) -> Kind:
+    if do_type is None:
+        return "expense"
+    if isinstance(do_type, str):
+        text = do_type.strip()
+        if text.lstrip("-").isdigit():
+            return type_map.get(int(text), "expense")
+        return cast(Kind, STRING_TYPE_MAP.get(text.lower(), "expense"))
+    try:
+        return type_map.get(int(cast(Any, do_type)), "expense")
+    except (TypeError, ValueError):
+        return "expense"
+
+
+def _month_label(day: date) -> str:
+    return day.strftime("%Y-%m")
+
+
+def _iso_week_start(day: date) -> date:
+    return day - timedelta(days=day.weekday())
+
+
+class _ManagedConnection(sqlite3.Connection):
+    _cleanup_path: Path | None = None
+
+    def close(self) -> None:
+        cleanup = self._cleanup_path
+        try:
+            super().close()
+        finally:
+            if cleanup is not None:
+                cleanup.unlink(missing_ok=True)
+
+
+def _connect_file(path: Path, *, readonly: bool, cleanup: Path | None = None) -> sqlite3.Connection:
+    uri = f"file:{path.resolve()}?mode=ro" if readonly else str(path)
+    con = sqlite3.connect(uri, uri=readonly, factory=_ManagedConnection)
+    con.row_factory = sqlite3.Row
+    con._cleanup_path = cleanup
+    return con
+
+
+def _temp_connection_from_bytes(data: bytes, directory: Path | None = None) -> sqlite3.Connection:
+    with tempfile.NamedTemporaryFile(suffix=".sqlite", dir=directory, delete=False) as handle:
+        handle.write(data)
+        name = Path(handle.name)
+    return _connect_file(name, readonly=True, cleanup=name)
+
+
+def _connection_from_bytes(data: bytes, directory: Path | None = None) -> sqlite3.Connection:
+    con = sqlite3.connect(":memory:")
+    con.row_factory = sqlite3.Row
+    if hasattr(con, "deserialize"):
+        con.deserialize(data)
+        return con
+    con.close()
+    return _temp_connection_from_bytes(data, directory)
+
+
+def _read_db_bytes_from_zip(data: bytes, label: str = "backup") -> bytes:
+    with zipfile.ZipFile(io.BytesIO(data)) as archive:
+        members = [name for name in archive.namelist() if not name.endswith("/")]
+        if not members:
+            raise ValueError(f"empty .mmbak archive: {label}")
+        member = next(
+            (name for name in members if name.lower().endswith((".sqlite", ".db", ".mmbak"))),
+            None,
+        )
+        if member is None:
+            member = max(members, key=lambda name: archive.getinfo(name).file_size)
+        return archive.read(member)
+
+
+def _open_mmbak(path: os.PathLike[str] | str) -> sqlite3.Connection:
+    file_path = Path(path)
+    data = file_path.read_bytes()
+    if zipfile.is_zipfile(file_path):
+        return _connection_from_bytes(
+            _read_db_bytes_from_zip(data, str(file_path)), file_path.parent
+        )
+    return _connect_file(file_path, readonly=True)
+
+
+def _name_map(con: sqlite3.Connection, table: str | None) -> dict[str, str]:
+    if not table:
+        return {}
+    cols = _table_columns(con, table)
+    name_col = _first_present(NAME_COLS, cols)
+    if not name_col:
+        return {}
+    id_cols = [col for col in UID_COLS if col in cols]
+    if not id_cols:
+        return {}
+    selected = ", ".join(f'"{col}" AS k{index}' for index, col in enumerate(id_cols))
+    out: dict[str, str] = {}
+    for row in con.execute(f'SELECT {selected}, "{name_col}" AS n FROM "{table}"'):
+        for index in range(len(id_cols)):
+            value = row[f"k{index}"]
+            if value is not None and value != "":
+                out.setdefault(str(value), str(row["n"]))
+    return out
+
+
+def _period_bound(value: str, *, is_end: bool) -> date:
+    text = value.strip()
+    parts = text.split("-")
+    if len(parts) == 2:
+        year, month = int(parts[0]), int(parts[1])
+        if is_end:
+            return date(year, month, calendar.monthrange(year, month)[1])
+        return date(year, month, 1)
+    return datetime.strptime(text, "%Y-%m-%d").date()
+
+
+@dataclass(frozen=True, slots=True)
+class _ResolvedSchema:
+    txn_table: str
+    amount: str
+    date_col: str
+    type_col: str | None
+    category_fk: str | None
+    category_name: str | None
+    asset_fk: str | None
+    memo: str | None
+    category_table: str | None
+    asset_table: str | None
+    currency_table: str | None
+
+
+class MoneyManagerBackup:
+    """A parsed, offline Realbyte Money Manager backup.
+
+    Income rows are preserved and exposed. The backup's currencies are read from
+    the ``CURRENCY`` table when present; ``currency()`` returns the main currency.
+    """
+
+    def __init__(
+        self, con: sqlite3.Connection, *, type_map: Mapping[int, str] | None = None
+    ) -> None:
+        self._con = con
+        self._type_map = _normal_type_map(type_map)
+        self._schema = self._resolve_schema()
+        self._categories = _name_map(con, self._schema.category_table)
+        self._account_names = _name_map(con, self._schema.asset_table)
+
+    @classmethod
+    def from_file(
+        cls, path: os.PathLike[str] | str, *, type_map: Mapping[int, str] | None = None
+    ) -> MoneyManagerBackup:
+        return cls(_open_mmbak(path), type_map=type_map)
+
+    @classmethod
+    def from_bytes(
+        cls, data: bytes, *, type_map: Mapping[int, str] | None = None
+    ) -> MoneyManagerBackup:
+        payload = (
+            _read_db_bytes_from_zip(data, "bytes") if zipfile.is_zipfile(io.BytesIO(data)) else data
+        )
+        return cls(_connection_from_bytes(payload), type_map=type_map)
+
+    def close(self) -> None:
+        self._con.close()
+
+    def __enter__(self) -> MoneyManagerBackup:
+        return self
+
+    def __exit__(self, *_exc: object) -> None:
+        self.close()
+
+    def _resolve_schema(self) -> _ResolvedSchema:
+        tables = _list_tables(self._con)
+        txn_table = _pick_table(self._con, TXN_TABLE_CANDIDATES, tables)
+        if not txn_table:
+            raise ValueError(f"no transaction table found; tables={tables}")
+        cols = _table_columns(self._con, txn_table)
+        amount = _first_present(AMOUNT_COLS, cols)
+        date_col = _first_present(DATE_COLS, cols)
+        if not amount or not date_col:
+            raise ValueError(f"missing amount/date columns in {txn_table}: {cols}")
+        return _ResolvedSchema(
+            txn_table=txn_table,
+            amount=amount,
+            date_col=date_col,
+            type_col=_first_present(TYPE_COLS, cols),
+            category_fk=_first_present(CATFK_COLS, cols),
+            category_name=_first_present(CATNAME_COLS, cols),
+            asset_fk=_first_present(ASSETFK_COLS, cols),
+            memo=_first_present(MEMO_COLS, cols),
+            category_table=_pick_table(self._con, CATEGORY_TABLE_CANDIDATES, tables),
+            asset_table=_pick_table(self._con, ASSET_TABLE_CANDIDATES, tables),
+            currency_table=_pick_table(self._con, CURRENCY_TABLE_CANDIDATES, tables),
+        )
+
+    def _iter_rows(self) -> Iterator[sqlite3.Row]:
+        s = self._schema
+        cols = [f'"{s.amount}" AS amt', f'"{s.date_col}" AS dt']
+        cols.append(f'"{s.type_col}" AS ty' if s.type_col else "NULL AS ty")
+        cols.append(f'"{s.category_fk}" AS cat' if s.category_fk else "NULL AS cat")
+        cols.append(f'"{s.category_name}" AS catname' if s.category_name else "NULL AS catname")
+        cols.append(f'"{s.asset_fk}" AS asset' if s.asset_fk else "NULL AS asset")
+        cols.append(f'"{s.memo}" AS memo' if s.memo else "NULL AS memo")
+        yield from self._con.execute(f'SELECT {", ".join(cols)} FROM "{s.txn_table}"')
+
+    def transactions(self) -> list[Transaction]:
+        out: list[Transaction] = []
+        for row in self._iter_rows():
+            parsed = _parse_date(row["dt"])
+            if parsed is None:
+                continue
+            cat = row["catname"] or self._categories.get(str(row["cat"])) or "Uncategorized"
+            account = (
+                self._account_names.get(str(row["asset"])) if row["asset"] is not None else None
+            )
+            out.append(
+                Transaction(
+                    amount=abs(_to_float(row["amt"])),
+                    date=parsed,
+                    kind=_kind(row["ty"], self._type_map),
+                    category=str(cat),
+                    memo=str(row["memo"] or ""),
+                    account=account,
+                )
+            )
+        return out
+
+    def categories(self) -> list[str]:
+        names = set(self._categories.values())
+        names.update(txn.category for txn in self.transactions())
+        return sorted(names)
+
+    def accounts(self) -> list[Account]:
+        asset_table = self._schema.asset_table
+        if not asset_table:
+            return []
+        cols = _table_columns(self._con, asset_table)
+        name_col = _first_present(NAME_COLS, cols)
+        balance_col = _first_present(BALANCE_COLS, cols)
+        if not name_col or not balance_col:
+            return []
+        return [
+            Account(name=str(row["n"]), balance=_to_float(row["b"]))
+            for row in self._con.execute(
+                f'SELECT "{name_col}" AS n, "{balance_col}" AS b FROM "{asset_table}"'
+            )
+        ]
+
+    def currencies(self) -> list[Currency]:
+        table = self._schema.currency_table
+        if not table:
+            return []
+        cols = _table_columns(self._con, table)
+        iso_col = _first_present(CURRENCY_ISO_COLS, cols)
+        symbol_col = _first_present(CURRENCY_SYMBOL_COLS, cols)
+        if not iso_col and not symbol_col:
+            return []
+        name_col = _first_present(NAME_COLS, cols)
+        main_col = _first_present(CURRENCY_MAIN_COLS, cols)
+        select = [
+            f'"{iso_col}" AS iso' if iso_col else "'' AS iso",
+            f'"{symbol_col}" AS sym' if symbol_col else "'' AS sym",
+            f'"{name_col}" AS nm' if name_col else "'' AS nm",
+            f'"{main_col}" AS mn' if main_col else "0 AS mn",
+        ]
+        return [
+            Currency(
+                iso=str(row["iso"] or ""),
+                symbol=str(row["sym"] or ""),
+                name=str(row["nm"] or ""),
+                is_main=bool(_to_float(row["mn"])),
+            )
+            for row in self._con.execute(f'SELECT {", ".join(select)} FROM "{table}"')
+        ]
+
+    def currency(self) -> Currency | None:
+        items = self.currencies()
+        if not items:
+            return None
+        for item in items:
+            if item.is_main:
+                return item
+        return items[0]
+
+    def schema(self) -> JsonDict:
+        tables = _list_tables(self._con)
+        out: JsonDict = {"tables": {table: _table_columns(self._con, table) for table in tables}}
+        s = self._schema
+        out["transaction_table"] = s.txn_table
+        out["resolved_columns"] = {
+            "amount": s.amount,
+            "date": s.date_col,
+            "type": s.type_col,
+            "category_fk": s.category_fk,
+            "category_name": s.category_name,
+            "asset_fk": s.asset_fk,
+            "memo": s.memo,
+        }
+        if s.type_col:
+            rows = self._con.execute(
+                f'SELECT "{s.type_col}" AS ty, COUNT(*) n, SUM(ABS("{s.amount}")) total '
+                f'FROM "{s.txn_table}" GROUP BY "{s.type_col}"'
+            )
+            out["do_type_breakdown"] = [
+                {
+                    "do_type": str(row["ty"]),
+                    "count": int(row["n"]),
+                    "abs_total": _to_float(row["total"]),
+                }
+                for row in rows
+            ]
+        return out
+
+    def query(
+        self,
+        *,
+        date_from: str | date | None = None,
+        date_to: str | date | None = None,
+        month: str | None = None,
+        category: str | None = None,
+        search: str | None = None,
+        kind: QueryKind = "expense",
+        group_by: GroupBy | None = None,
+        top: int | None = None,
+        list_n: int | None = None,
+        limit: int = 24,
+    ) -> QueryResult:
+        if kind not in {"expense", "income", "all"}:
+            raise ValueError("kind must be expense, income, or all")
+        if month:
+            date_from = month
+            date_to = month
+        start = _period_bound(date_from, is_end=False) if isinstance(date_from, str) else date_from
+        end = _period_bound(date_to, is_end=True) if isinstance(date_to, str) else date_to
+        cat_want = category.strip().lower() if category else None
+        search_want = search.strip().lower() if search else None
+        matches: list[Transaction] = []
+        for txn in self.transactions():
+            if txn.kind == "transfer":
+                continue
+            if kind != "all" and txn.kind != kind:
+                continue
+            if start and txn.date < start:
+                continue
+            if end and txn.date > end:
+                continue
+            if cat_want and txn.category.lower() != cat_want:
+                continue
+            if (
+                search_want
+                and search_want not in txn.memo.lower()
+                and search_want not in txn.category.lower()
+            ):
+                continue
+            matches.append(txn)
+        total = sum(txn.amount for txn in matches)
+        dates = [txn.date for txn in matches]
+        filters: JsonDict = {
+            "from": start.isoformat() if start else None,
+            "to": end.isoformat() if end else None,
+            "category": category,
+            "search": search,
+            "kind": kind,
+        }
+        summary: JsonDict = {
+            "total": round(total),
+            "count": len(matches),
+            "avg_per_txn": round(total / len(matches)) if matches else 0,
+            "date_min": min(dates).isoformat() if dates else None,
+            "date_max": max(dates).isoformat() if dates else None,
+        }
+        result = QueryResult(status="ok", filters=filters, summary=summary)
+        if group_by:
+            groups: dict[str, list[float]] = {}
+            for txn in matches:
+                if group_by == "month":
+                    key = _month_label(txn.date)
+                elif group_by == "day":
+                    key = txn.date.isoformat()
+                elif group_by == "week":
+                    key = _iso_week_start(txn.date).isoformat()
+                else:
+                    key = txn.category
+                bucket = groups.setdefault(key, [0.0, 0.0])
+                bucket[0] += txn.amount
+                bucket[1] += 1
+            items = list(groups.items())
+            items.sort(
+                key=(lambda item: item[1][0]), reverse=True
+            ) if group_by == "category" else items.sort(key=lambda item: item[0])
+            result = QueryResult(
+                status="ok",
+                filters=filters,
+                summary=summary,
+                group_by=group_by,
+                groups=[
+                    {"key": key, "total": round(value[0]), "count": int(value[1])}
+                    for key, value in items[:limit]
+                ],
+            )
+        if top:
+            tops = sorted(matches, key=lambda txn: txn.amount, reverse=True)[:top]
+            result.top.extend(
+                {
+                    "amount": round(txn.amount),
+                    "category": txn.category,
+                    "memo": txn.memo[:60],
+                    "date": txn.date.isoformat(),
+                }
+                for txn in tops
+            )
+        if list_n:
+            recent = sorted(matches, key=lambda txn: txn.date, reverse=True)[:list_n]
+            result.transactions.extend(
+                {
+                    "date": txn.date.isoformat(),
+                    "amount": round(txn.amount),
+                    "category": txn.category,
+                    "memo": txn.memo[:60],
+                }
+                for txn in recent
+            )
+        if not (group_by or top or list_n):
+            cats: dict[str, float] = {}
+            for txn in matches:
+                cats[txn.category] = cats.get(txn.category, 0.0) + txn.amount
+            result.categories.extend(
+                {"name": name, "total": round(value)}
+                for name, value in sorted(cats.items(), key=lambda item: item[1], reverse=True)[
+                    :limit
+                ]
+            )
+        return result

moneymanager_parser/models.py

@@ -0,0 +1,63 @@
+"""Public dataclasses returned by the SDK."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from datetime import date
+from typing import Any, Literal
+
+Kind = Literal["income", "expense", "transfer"]
+GroupBy = Literal["month", "category", "day", "week"]
+QueryKind = Literal["expense", "income", "all"]
+
+JsonValue = Any
+JsonDict = dict[str, Any]
+
+
+@dataclass(frozen=True, slots=True)
+class Transaction:
+    amount: float
+    date: date
+    kind: Kind
+    category: str
+    memo: str
+    account: str | None = None
+
+
+@dataclass(frozen=True, slots=True)
+class Account:
+    name: str
+    balance: float
+
+
+@dataclass(frozen=True, slots=True)
+class Currency:
+    iso: str
+    symbol: str
+    name: str = ""
+    is_main: bool = False
+
+
+@dataclass(frozen=True, slots=True)
+class QueryResult:
+    status: str
+    filters: JsonDict
+    summary: JsonDict
+    group_by: str | None = None
+    groups: list[JsonDict] = field(default_factory=list)
+    top: list[JsonDict] = field(default_factory=list)
+    transactions: list[JsonDict] = field(default_factory=list)
+    categories: list[JsonDict] = field(default_factory=list)
+
+    def as_dict(self) -> JsonDict:
+        out: JsonDict = {"status": self.status, "filters": self.filters, "summary": self.summary}
+        if self.group_by:
+            out["group_by"] = self.group_by
+            out["groups"] = self.groups
+        if self.top:
+            out["top"] = self.top
+        if self.transactions:
+            out["transactions"] = self.transactions
+        if self.categories:
+            out["categories"] = self.categories
+        return out

moneymanager_parser/schema.py

@@ -0,0 +1,36 @@
+"""Schema aliases used by Realbyte Money Manager releases."""
+
+TXN_TABLE_CANDIDATES = ("INOUTCOME", "ZINOUTCOME", "inoutcome")
+CATEGORY_TABLE_CANDIDATES = ("ZCATEGORY", "CATEGORY", "category")
+ASSET_TABLE_CANDIDATES = ("ASSETS", "ZASSETS", "ASSET", "assets")
+CURRENCY_TABLE_CANDIDATES = ("CURRENCY", "ZCURRENCY", "currency")
+
+AMOUNT_COLS = ("ZMONEY", "AMOUNT", "amount", "money", "ZAMOUNT")
+DATE_COLS = ("WDATE", "wdate", "ZDATE", "DATE", "date", "ZTIME")
+TYPE_COLS = ("DO_TYPE", "type", "TYPE", "ZTYPE", "inoutType")
+CATFK_COLS = ("ctgUid", "CTGUID", "ZCATEGORY", "category_id", "categoryUid", "ctg_uid")
+CATNAME_COLS = ("CATEGORY_NAME", "category_name", "ZCTGNAME", "ctgName")
+ASSETFK_COLS = ("assetUid", "ASSETUID", "ASSETS", "account_id", "asset_uid")
+MEMO_COLS = ("ZCONTENT", "MEMO", "memo", "content", "ZCOMMENT", "comment")
+
+NAME_COLS = ("ZNAME", "NAME", "name", "title", "ZTITLE")
+UID_COLS = ("uid", "UID", "C_UID", "_id", "id", "ID", "ZUID")
+BALANCE_COLS = ("ZMONEY", "AMOUNT", "amount", "balance", "ZAMOUNT")
+
+CURRENCY_ISO_COLS = ("ISO", "iso", "CODE", "code", "ZISO")
+CURRENCY_SYMBOL_COLS = ("SYMBOL", "symbol", "ZSYMBOL")
+CURRENCY_MAIN_COLS = ("IS_MAIN_CURRENCY", "is_main_currency", "IS_MAIN", "ZISMAIN")
+
+DEFAULT_TYPE_MAP = {0: "income", 1: "expense", 2: "transfer", 3: "transfer", 4: "transfer"}
+STRING_TYPE_MAP = {
+    "income": "income",
+    "in": "income",
+    "0": "income",
+    "expense": "expense",
+    "out": "expense",
+    "1": "expense",
+    "transfer": "transfer",
+    "trans": "transfer",
+    "2": "transfer",
+    "3": "transfer",
+}

moneymanager_parser-0.1.0.dist-info/METADATA

@@ -0,0 +1,104 @@
+Metadata-Version: 2.4
+Name: moneymanager-parser
+Version: 0.1.0
+Summary: Typed parser and query SDK for Realbyte Money Manager .mmbak backups.
+Project-URL: Homepage, https://github.com/shubham1172/moneymanager-parser
+Project-URL: Repository, https://github.com/shubham1172/moneymanager-parser
+Project-URL: Issues, https://github.com/shubham1172/moneymanager-parser/issues
+Author-email: Shubham Sharma <shubhamsharma1172@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: finance,mmbak,money-manager,realbyte,sqlite
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Provides-Extra: dev
+Requires-Dist: build>=1.2; extra == 'dev'
+Requires-Dist: mypy>=1.10; extra == 'dev'
+Requires-Dist: pytest-cov>=5.0; extra == 'dev'
+Requires-Dist: pytest>=8.2; extra == 'dev'
+Requires-Dist: ruff>=0.5; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# moneymanager-parser
+
+[![CI](https://github.com/shubham1172/moneymanager-parser/actions/workflows/ci.yml/badge.svg)](https://github.com/shubham1172/moneymanager-parser/actions/workflows/ci.yml)
+![PyPI](https://img.shields.io/badge/PyPI-unpublished-lightgrey)
+
+Typed Python SDK and offline CLI for Realbyte Money Manager `.mmbak` exports.
+
+A `.mmbak` export is a ZIP-wrapped SQLite database. This package reads the export locally,
+resolves common schema aliases across app versions, and exposes transactions, summaries, flexible
+queries, schema inspection, categories, accounts, and currencies. Core parsing uses only the Python
+standard library. Income is exposed by the API, but expense-oriented analysis should treat it as
+informational because Money Manager exports can vary by installation.
+
+The backup's currencies are read from the `CURRENCY` table when present. `currency()` returns the main
+currency (`ISO`, `symbol`, `name`); amounts are stored in the account/transaction currency and are not
+converted.
+
+## Install
+
+After the first release:
+
+```bash
+pip install moneymanager-parser
+```
+
+## Quickstart
+
+```python
+from moneymanager_parser import MoneyManagerBackup
+
+with MoneyManagerBackup.from_file("backup.mmbak") as backup:
+    main = backup.currency()
+    if main:
+        print(main.iso, main.symbol)
+    for txn in backup.transactions():
+        print(txn.date, txn.kind, txn.category, txn.amount)
+    print(backup.query(month="2026-01", group_by="category").as_dict())
+```
+
+Custom transaction type maps are supported:
+
+```python
+MoneyManagerBackup.from_file("backup.mmbak", type_map={0: "income", 1: "expense", 7: "transfer"})
+```
+
+## CLI
+
+```bash
+mmbak query backup.mmbak --month 2026-01 --group-by category --top 10
+mmbak schema backup.mmbak
+mmbak currency backup.mmbak
+```
+
+All commands print JSON and never contact external services.
+
+## Development
+
+```bash
+python3 -m venv .venv
+. .venv/bin/activate
+pip install -e '.[dev]'
+ruff check .
+ruff format --check .
+mypy src
+pytest --cov
+```
+
+## Contributing
+
+Issues and pull requests are welcome. Please include tests for schema variants and avoid committing
+personal exports; test backups should be generated synthetically.
+
+## License
+
+MIT © 2026 Shubham Sharma

moneymanager_parser-0.1.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+moneymanager_parser/__init__.py,sha256=r-dBbZhURX0KCQsn87hM_U0wHcEGYKolr7KD69Vz0cU,311
+moneymanager_parser/cli.py,sha256=XaL_oe-_0JbTxzmxqvdgE4A26g8BN9JrlZtpw-MIgKc,2874
+moneymanager_parser/core.py,sha256=R42JOpDWrG6VZVK1PhLqF377r-O8EVbRWH3b_tNS-7s,19734
+moneymanager_parser/models.py,sha256=cSupPAAJWGH8Pd7HINMjTIZmSZwWdv5tc0iFZBcJh0w,1618
+moneymanager_parser/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+moneymanager_parser/schema.py,sha256=37bQbbMMzwqrBBTgxrI184nLOOLOVhl6dABJ_3SiPow,1559
+moneymanager_parser-0.1.0.dist-info/METADATA,sha256=nn7mGiLZJQc_VD-aVeZ-qLsHsOqOjcy84HyvHAbdD40,3480
+moneymanager_parser-0.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+moneymanager_parser-0.1.0.dist-info/entry_points.txt,sha256=M1bUPmBeQRw1Qaphkywo8RmpbzJ0m67t2HdIkZeUM9g,55
+moneymanager_parser-0.1.0.dist-info/licenses/LICENSE,sha256=U9afe1B-vmXT-7exsQJLiYToBjmWuUgKuEtue-Vqopk,1071
+moneymanager_parser-0.1.0.dist-info/RECORD,,

moneymanager_parser-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

moneymanager_parser-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+mmbak = moneymanager_parser.cli:main

moneymanager_parser-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Shubham Sharma
+
+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.