moneywiz-api 0.0.1__tar.gz

moneywiz-api-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Tianwei Dong
+
+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.

moneywiz-api-0.0.1/PKG-INFO

@@ -0,0 +1,61 @@
+Metadata-Version: 2.1
+Name: moneywiz-api
+Version: 0.0.1
+Summary: A Python api to access moneywiz sqlite database
+Author-email: iLeoDo <iLeoDo@gmail.com>
+Project-URL: Homepage, https://github.com/ileodo/moneywiz-api
+Project-URL: Bug Tracker, https://github.com/ileodo/moneywiz-api/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# MoneyWiz-API
+
+![Static Badge](https://img.shields.io/badge/Python-3-blue?style=flat&logo=Python)
+![PyPI](https://img.shields.io/pypi/v/moneywiz-api)
+
+
+<a href="https://www.buymeacoffee.com/Ileodo" target="_blank"><img src="https://cdn.buymeacoffee.com/buttons/v2/default-blue.png" alt="Buy Me A Coffee" style="height: 60px !important;width: 217px !important;" ></a>
+
+A Python API to access MoneyWiz Sqlite database.
+
+
+## Get Started
+
+```bash
+pip install moneywiz-api
+```
+
+```python
+
+from moneywiz_api import MoneywizApi
+
+moneywizApi = MoneywizApi("<path_to_your_sqlite_file>")
+
+(
+    accessor,
+    account_manager,
+    payee_manager,
+    category_manager,
+    transaction_manager,
+    investment_holding_manager,
+) = (
+    moneywizApi.accessor,
+    moneywizApi.account_manager,
+    moneywizApi.payee_manager,
+    moneywizApi.category_manager,
+    moneywizApi.transaction_manager,
+    moneywizApi.investment_holding_manager,
+)
+
+record = accessor.get_record(record_id)
+print(record)
+
+```
+
+## Contribution
+
+This project is in very early stage, all contributions are welcomed!

moneywiz-api-0.0.1/README.md

@@ -0,0 +1,47 @@
+# MoneyWiz-API
+
+![Static Badge](https://img.shields.io/badge/Python-3-blue?style=flat&logo=Python)
+![PyPI](https://img.shields.io/pypi/v/moneywiz-api)
+
+
+<a href="https://www.buymeacoffee.com/Ileodo" target="_blank"><img src="https://cdn.buymeacoffee.com/buttons/v2/default-blue.png" alt="Buy Me A Coffee" style="height: 60px !important;width: 217px !important;" ></a>
+
+A Python API to access MoneyWiz Sqlite database.
+
+
+## Get Started
+
+```bash
+pip install moneywiz-api
+```
+
+```python
+
+from moneywiz_api import MoneywizApi
+
+moneywizApi = MoneywizApi("<path_to_your_sqlite_file>")
+
+(
+    accessor,
+    account_manager,
+    payee_manager,
+    category_manager,
+    transaction_manager,
+    investment_holding_manager,
+) = (
+    moneywizApi.accessor,
+    moneywizApi.account_manager,
+    moneywizApi.payee_manager,
+    moneywizApi.category_manager,
+    moneywizApi.transaction_manager,
+    moneywizApi.investment_holding_manager,
+)
+
+record = accessor.get_record(record_id)
+print(record)
+
+```
+
+## Contribution
+
+This project is in very early stage, all contributions are welcomed!

moneywiz-api-0.0.1/pyproject.toml

@@ -0,0 +1,23 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+
+[project]
+name = "moneywiz-api"
+version = "0.0.1"
+authors = [
+    { name="iLeoDo", email="iLeoDo@gmail.com" },
+]
+description = "A Python api to access moneywiz sqlite database"
+readme = "README.md"
+requires-python = ">=3.7"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+
+[project.urls]
+"Homepage" = "https://github.com/ileodo/moneywiz-api"
+"Bug Tracker" = "https://github.com/ileodo/moneywiz-api/issues"

moneywiz-api-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

moneywiz-api-0.0.1/src/moneywiz_api/__init__.py

@@ -0,0 +1,3 @@
+from src.moneywiz_api.moneywiz_api import MoneywizApi
+
+__all__ = ["MoneywizApi"]

moneywiz-api-0.0.1/src/moneywiz_api/database_accessor.py

@@ -0,0 +1,99 @@
+import sqlite3
+from collections import defaultdict
+from pathlib import Path
+from typing import Dict, List, Any, Callable, Tuple
+
+from src.moneywiz_api.model.record import Record
+from src.moneywiz_api.types import ENT_ID, ID
+
+
+class DatabaseAccessor:
+    def __init__(self, db_path: Path):
+        self._con = sqlite3.connect(db_path, uri=True)
+
+        def dict_factory(cursor, row):
+            record = {}
+            for idx, col in enumerate(cursor.description):
+                record[col[0]] = row[idx]
+            return record
+
+        self._con.row_factory = dict_factory
+
+        self._ent_to_typename: Dict[ENT_ID, str] = self._load_primarykey()
+        self._typename_to_ent: Dict[str, ENT_ID] = {
+            v: k for k, v in self._ent_to_typename.items()
+        }
+
+    def _load_primarykey(self) -> Dict[int, str]:
+        cur = self._con.cursor()
+        res = cur.execute(
+            """
+        SELECT * FROM  "Z_PRIMARYKEY" ORDER BY "Z_ENT" LIMIT 1000 OFFSET 0;
+        """
+        )
+        ent_to_typename: Dict[int, str] = {}
+        for row in res.fetchall():
+            ent_to_typename[row["Z_ENT"]] = row["Z_NAME"]
+        return ent_to_typename
+
+    def __repr__(self):
+        return "\n".join(
+            f"{key}: {value}" for key, value in self._ent_to_typename.items()
+        )
+
+    def typename_for(self, ent_id: ENT_ID) -> str:
+        return self._ent_to_typename.get(ent_id)
+
+    def ent_for(self, typename: str) -> ENT_ID:
+        return self._typename_to_ent.get(typename)
+
+    def query_objects(self, typenames: List[str]) -> List[Any]:
+        cur = self._con.cursor()
+        res = cur.execute(
+            """
+        SELECT * FROM ZSYNCOBJECT WHERE Z_ENT in (%s)
+        """
+            % (",".join("?" * len(typenames))),
+            [self.ent_for(x) for x in typenames],
+        )
+        return res.fetchall()
+
+    def get_record(self, pk_id: ID, constructor: Callable = Record):
+        cur = self._con.cursor()
+        res = cur.execute(
+            """
+        SELECT * FROM ZSYNCOBJECT WHERE Z_PK = ?
+        
+        """,
+            [pk_id],
+        )
+
+        return constructor(res.fetchone())
+
+    def get_category_assignment(self) -> Dict[ID, List[Tuple[ID, float]]]:
+        transaction_map: Dict[ID, List[Tuple[ID, float]]] = defaultdict(list)
+        cur = self._con.cursor()
+        res = cur.execute(
+            """
+        SELECT ZCATEGORY, ZTRANSACTION, ZAMOUNT  FROM ZCATEGORYASSIGMENT WHERE ZTRANSACTION IS NOT NULL
+        
+        """
+        )
+        for row in res.fetchall():
+            transaction_map[row["ZTRANSACTION"]].append(
+                (row["ZCATEGORY"], row["ZAMOUNT"])
+            )
+        return transaction_map
+
+    def get_refund_maps(self) -> Dict[ID, ID]:
+        refund_to_withdraw: Dict[ID, ID] = {}
+        cur = self._con.cursor()
+        res = cur.execute(
+            """
+        SELECT ZREFUNDTRANSACTION, ZWITHDRAWTRANSACTION  FROM ZWITHDRAWREFUNDTRANSACTIONLINK
+        
+        """
+        )
+        for row in res.fetchall():
+            refund_to_withdraw[row["ZREFUNDTRANSACTION"]] = row["ZWITHDRAWTRANSACTION"]
+        return refund_to_withdraw

moneywiz-api-0.0.1/src/moneywiz_api/managers/account_manager.py

@@ -0,0 +1,43 @@
+from typing import Dict, Callable, List
+
+from src.moneywiz_api.model.account import Account
+from src.moneywiz_api.managers.record_manager import RecordManager
+
+from src.moneywiz_api.model.account import (
+    BankChequeAccount,
+    BankSavingAccount,
+    CashAccount,
+    CreditCardAccount,
+    LoanAccount,
+    InvestmentAccount,
+    ForexAccount,
+)
+from src.moneywiz_api.types import ID
+
+
+class AccountManager(RecordManager[Account]):
+    def __init__(self):
+        super().__init__()
+
+    @property
+    def ents(self) -> Dict[str, Callable]:
+        return {
+            "BankChequeAccount": BankChequeAccount,
+            "BankSavingAccount": BankSavingAccount,
+            "CashAccount": CashAccount,
+            "CreditCardAccount": CreditCardAccount,
+            "LoanAccount": LoanAccount,
+            "InvestmentAccount": InvestmentAccount,
+            "ForexAccount": ForexAccount,
+        }
+
+    def records(self) -> Dict[ID, Account]:
+        return dict(
+            sorted(super().records().items(), key=lambda x: x[1]._display_order)
+        )
+
+    def get_accounts_for_user(self, user_id: ID) -> List[Account]:
+        return sorted(
+            [x for _, x in self.records().items() if x.user == user_id],
+            key=lambda x: (x._group_id, x._display_order),
+        )

moneywiz-api-0.0.1/src/moneywiz_api/managers/category_manager.py

@@ -0,0 +1,33 @@
+from typing import Dict, Callable, List
+
+from src.moneywiz_api.model.category import Category
+from src.moneywiz_api.managers.record_manager import RecordManager
+from src.moneywiz_api.types import ID
+
+
+class CategoryManager(RecordManager[Category]):
+    def __init__(self):
+        super().__init__()
+
+    @property
+    def ents(self) -> Dict[str, Callable]:
+        return {
+            "Category": Category,
+        }
+
+    def get_name_chain(self, category_id: ID) -> List[str]:
+        ret: List[str] = []
+        current = self.get(category_id)
+        while current:
+            ret.insert(0, current.name)
+            if not current.parentId:
+                break
+            else:
+                current = self.get(current.parentId)
+        return ret
+
+    def get_categories_for_user(self, user_id: ID) -> List[Category]:
+        return sorted(
+            [x for _, x in self.records().items() if x.user == user_id],
+            key=lambda x: x.type,
+        )

moneywiz-api-0.0.1/src/moneywiz_api/managers/investment_holding_manager.py

@@ -0,0 +1,19 @@
+from typing import Dict, Callable, List
+
+from src.moneywiz_api.model.investment_holding import InvestmentHolding
+from src.moneywiz_api.managers.record_manager import RecordManager
+from src.moneywiz_api.types import ID
+
+
+class InvestmentHoldingManager(RecordManager[InvestmentHolding]):
+    def __init__(self):
+        super().__init__()
+
+    @property
+    def ents(self) -> Dict[str, Callable]:
+        return {
+            "InvestmentHolding": InvestmentHolding,
+        }
+
+    def get_holdings_for_account(self, account_id: ID) -> List[InvestmentHolding]:
+        return [x for _, x in self.records().items() if x.account == account_id]

moneywiz-api-0.0.1/src/moneywiz_api/managers/payee_manager.py

@@ -0,0 +1,15 @@
+from typing import Dict, Callable
+
+from src.moneywiz_api.model.payee import Payee
+from src.moneywiz_api.managers.record_manager import RecordManager
+
+
+class PayeeManager(RecordManager[Payee]):
+    def __init__(self):
+        super().__init__()
+
+    @property
+    def ents(self) -> Dict[str, Callable]:
+        return {
+            "Payee": Payee,
+        }

moneywiz-api-0.0.1/src/moneywiz_api/managers/record_manager.py

@@ -0,0 +1,40 @@
+from abc import ABC, abstractmethod
+from typing import Dict, Generic, TypeVar, Callable
+
+from src.moneywiz_api.database_accessor import DatabaseAccessor
+from src.moneywiz_api.model.record import Record
+from src.moneywiz_api.types import ID
+
+
+T = TypeVar("T", bound=Record)
+
+
+class RecordManager(ABC, Generic[T]):
+    def __init__(self):
+        self._records: Dict[ID, T] = {}
+
+    @property
+    @abstractmethod
+    def ents(self) -> Dict[str, Callable]:
+        raise NotImplementedError()
+
+    def load(self, db_accessor: DatabaseAccessor) -> None:
+        records = db_accessor.query_objects(self.ents.keys())
+
+        for record in records:
+            typename = db_accessor.typename_for(record["Z_ENT"])
+            if typename in self.ents:
+                obj = self.ents[typename](record)
+                self.add(obj)
+
+    def add(self, record: T) -> None:
+        self._records[record.id] = record
+
+    def get(self, record_id: ID) -> T | None:
+        return self._records.get(record_id)
+
+    def records(self) -> Dict[ID, T]:
+        return self._records
+
+    def __repr__(self):
+        return "\n".join(f"{key}: {value}" for key, value in self.records().items())

moneywiz-api-0.0.1/src/moneywiz_api/managers/transaction_manager.py

@@ -0,0 +1,90 @@
+from datetime import datetime
+from typing import Dict, Callable, List, Tuple
+
+from src.moneywiz_api import utils
+from src.moneywiz_api.database_accessor import DatabaseAccessor
+from src.moneywiz_api.model.transaction import (
+    Transaction,
+    DepositTransaction,
+    InvestmentExchangeTransaction,
+    InvestmentBuyTransaction,
+    InvestmentSellTransaction,
+    ReconcileTransaction,
+    RefundTransaction,
+    TransferBudgetTransaction,
+    TransferDepositTransaction,
+    TransferWithdrawTransaction,
+    WithdrawTransaction,
+)
+from src.moneywiz_api.managers.record_manager import RecordManager
+from src.moneywiz_api.types import ID
+
+
+class TransactionManager(RecordManager[Transaction]):
+    def __init__(self):
+        super().__init__()
+        self.category_assignment: Dict[ID, List[Tuple[ID, float]]] = {}
+        self.refund_maps: Dict[ID, ID] = {}
+
+    @property
+    def ents(self) -> Dict[str, Callable]:
+        return {
+            "DepositTransaction": DepositTransaction,
+            "InvestmentExchangeTransaction": InvestmentExchangeTransaction,
+            "InvestmentBuyTransaction": InvestmentBuyTransaction,
+            "InvestmentSellTransaction": InvestmentSellTransaction,
+            "ReconcileTransaction": ReconcileTransaction,
+            "RefundTransaction": RefundTransaction,
+            "TransferBudgetTransaction": TransferBudgetTransaction,
+            "TransferDepositTransaction": TransferDepositTransaction,
+            "TransferWithdrawTransaction": TransferWithdrawTransaction,
+            "WithdrawTransaction": WithdrawTransaction,
+        }
+
+    def load(self, db_accessor: DatabaseAccessor) -> None:
+        super().load(db_accessor)
+        self.category_assignment: Dict[
+            ID, List[Tuple[ID, float]]
+        ] = db_accessor.get_category_assignment()
+        self.refund_maps: Dict[ID, ID] = db_accessor.get_refund_maps()
+
+    def category_for_transaction(
+        self, transaction_id: ID
+    ) -> List[Tuple[ID, float]] | None:
+        return self.category_assignment.get(transaction_id)
+
+    def original_transaction_for_refund_transaction(
+        self, transaction_id: ID
+    ) -> ID | None:
+        return self.refund_maps.get(transaction_id)
+
+    def get_all_for_account(
+        self, account_id: ID, until: datetime = datetime.now()
+    ) -> List[Transaction]:
+        """
+        Get all transactions for a given account
+        :param account_id:
+        :param until: inclusive
+        :return:
+        """
+        return sorted(
+            [
+                x
+                for _, x in self.records().items()
+                if not isinstance(x, TransferBudgetTransaction)
+                and x.account == account_id
+                and x.date <= utils.get_date(until)
+            ],
+            key=lambda x: x.date,
+        )
+
+    def get_all(self, until: datetime = datetime.now()) -> List[Transaction]:
+        return sorted(
+            [
+                x
+                for _, x in self.records().items()
+                if not isinstance(x, TransferBudgetTransaction)
+                and x.date <= utils.get_date(until)
+            ],
+            key=lambda x: x.date,
+        )

moneywiz-api-0.0.1/src/moneywiz_api/model/account.py

@@ -0,0 +1,116 @@
+from abc import ABC
+from dataclasses import dataclass, field
+
+from src.moneywiz_api.model.record import Record
+from src.moneywiz_api.types import ID
+
+
+@dataclass
+class Account(Record, ABC):
+    """
+    ENT: 9
+    """
+
+    _display_order: int = field(repr=False)
+    _group_id: int = field(repr=False)
+
+    name: str
+    currency: str
+    opening_balance: float
+    info: str
+    user: ID
+
+    def __init__(self, row):
+        super().__init__(row)
+        self._display_order = row["ZDISPLAYORDER"]
+        self._group_id = row["ZGROUPID"]
+
+        self.name = row["ZNAME"]
+        self.currency = row["ZCURRENCYNAME"]
+        self.opening_balance = row["ZOPENINGBALANCE"]
+        self.info = row["ZINFO"]
+
+        self.user = row["ZUSER"]
+
+        # Validate
+        assert self.name is not None
+        assert self.currency is not None
+        assert self.opening_balance is not None
+        assert self.info is not None
+        assert self.user is not None
+
+
+@dataclass
+class BankChequeAccount(Account):
+    """
+    ENT: 10
+    """
+
+    def __init__(self, row):
+        super().__init__(row)
+
+
+@dataclass
+class BankSavingAccount(Account):
+    """
+    ENT: 11
+    """
+
+    def __init__(self, row):
+        super().__init__(row)
+
+
+@dataclass
+class CashAccount(Account):
+    """
+    ENT: 12
+    """
+
+    def __init__(self, row):
+        super().__init__(row)
+
+
+@dataclass
+class CreditCardAccount(Account):
+    """
+    ENT: 13
+    """
+
+    statement_day: int  # day in the month
+
+    def __init__(self, row):
+        super().__init__(row)
+        self.statement_day = row["ZSTATEMENTENDDAY"]
+
+        # Validate
+        assert self.statement_day is not None
+
+
+@dataclass
+class LoanAccount(CreditCardAccount):
+    """
+    ENT: 14
+    """
+
+    def __init__(self, row):
+        super().__init__(row)
+
+
+@dataclass
+class InvestmentAccount(Account):
+    """
+    ENT: 15
+    """
+
+    def __init__(self, row):
+        super().__init__(row)
+
+
+@dataclass
+class ForexAccount(InvestmentAccount):
+    """
+    ENT: 16
+    """
+
+    def __init__(self, row):
+        super().__init__(row)

moneywiz-api-0.0.1/src/moneywiz_api/model/category.py

@@ -0,0 +1,37 @@
+from dataclasses import dataclass
+from typing import Optional
+
+from src.moneywiz_api.model.record import Record
+from src.moneywiz_api.types import CategoryType, ID
+
+
+@dataclass
+class Category(Record):
+    """
+    ENT: 19
+    """
+
+    name: str
+    parentId: Optional[int]
+    type: CategoryType
+    user: ID
+
+    def __init__(self, row):
+        super().__init__(row)
+        self.name = row["ZNAME2"]
+        self.parentId = row["ZPARENTCATEGORY"]
+        self.type = self._convert_type(row["ZTYPE2"])
+        self.user = row["ZUSER3"]
+
+        # Validate
+        assert self.name is not None
+        assert self.type is not None
+        assert self.user is not None
+
+    @staticmethod
+    def _convert_type(type_: Optional[int]) -> CategoryType:
+        if not type_:
+            raise Exception("Invalid type")
+        if type_ not in [1, 2]:
+            raise Exception("Invalid type")
+        return "Expenses" if type_ == 1 else "Income"