tariochbctools 0.38__py2.py3-none-any.whl → 1.0.0__py2.py3-none-any.whl

tariochbctools/importers/netbenefits/importer.py

@@ -1,24 +1,23 @@
 import csv
+import re
 from collections.abc import Iterable
 from datetime import date
-from io import StringIO
 
+import beangulp
 from beancount.core import amount, data
 from beancount.core.number import D
 from beancount.core.position import CostSpec
-from beancount.ingest import importer
-from beancount.ingest.importers.mixins import identifier
 from dateutil.parser import parse
 
 from tariochbctools.importers.general.priceLookup import PriceLookup
 
 
-class Importer(identifier.IdentifyMixin, importer.ImporterProtocol):
+class Importer(beangulp.Importer):
     """An importer for Fidelity Netbenefits Activity CSV files."""
 
     def __init__(
         self,
-        regexps: str | Iterable[str],
+        filepattern: str,
         cashAccount: str,
         investmentAccount: str,
         dividendAccount: str,
@@ -28,7 +27,7 @@ class Importer(identifier.IdentifyMixin, importer.ImporterProtocol):
         ignoreTypes: Iterable[str],
         baseCcy: str,
     ):
-        identifier.IdentifyMixin.__init__(self, matchers=[("filename", regexps)])
+        self.filepattern = filepattern
         self.cashAccount = cashAccount
         self.investmentAccount = investmentAccount
         self.dividendAccount = dividendAccount
@@ -38,18 +37,21 @@ class Importer(identifier.IdentifyMixin, importer.ImporterProtocol):
         self.ignoreTypes = ignoreTypes
         self.baseCcy = baseCcy
 
-    def name(self):
+    def name(self) -> str:
         return super().name() + self.cashAccount
 
-    def file_account(self, file):
+    def identify(self, filepath: str) -> bool:
+        return re.search(self.filepattern, filepath) is not None
+
+    def account(self, filepath: str) -> data.Account:
         return self.cashAccount
 
-    def extract(self, file, existing_entries):
+    def extract(self, filepath: str, existing: data.Entries) -> data.Entries:
         entries = []
 
-        self.priceLookup = PriceLookup(existing_entries, self.baseCcy)
+        self.priceLookup = PriceLookup(existing, self.baseCcy)
 
-        with StringIO(file.contents()) as csvfile:
+        with open(filepath) as csvfile:
             reader = csv.DictReader(
                 csvfile,
                 [
@@ -76,12 +78,12 @@ class Importer(identifier.IdentifyMixin, importer.ImporterProtocol):
                 if row["Shares"] != "-":
                     shares = amount.Amount(D(row["Shares"]), self.symbol)
 
-                metakv = {}
+                metakv: data.Meta = {}
 
                 if not amt and not shares:
                     continue
 
-                meta = data.new_metadata(file.name, 0, metakv)
+                meta = data.new_metadata(filepath, 0, metakv)
                 description = row["Transaction type"].strip()
 
                 if "TAX" in description:
@@ -120,7 +122,9 @@ class Importer(identifier.IdentifyMixin, importer.ImporterProtocol):
 
         return entries
 
-    def __createBuy(self, amt: amount, shares: amount, book_date: date):
+    def __createBuy(
+        self, amt: amount, shares: amount, book_date: date
+    ) -> list[data.Posting]:
         price = self.priceLookup.fetchPrice("USD", book_date)
         cost = CostSpec(
             number_per=None,
@@ -137,7 +141,9 @@ class Importer(identifier.IdentifyMixin, importer.ImporterProtocol):
 
         return postings
 
-    def __createSell(self, amt: amount, shares: amount, book_date: date):
+    def __createSell(
+        self, amt: amount, shares: amount, book_date: date
+    ) -> list[data.Posting]:
         price = self.priceLookup.fetchPrice("USD", book_date)
         cost = CostSpec(
             number_per=None,
@@ -155,7 +161,9 @@ class Importer(identifier.IdentifyMixin, importer.ImporterProtocol):
 
         return postings
 
-    def __createDividend(self, amt: amount, book_date: date, incomeAccount: str):
+    def __createDividend(
+        self, amt: amount, book_date: date, incomeAccount: str
+    ) -> list[data.Posting]:
         price = self.priceLookup.fetchPrice("USD", book_date)
         postings = [
             data.Posting(

tariochbctools/importers/nordigen/importer.py

@@ -1,28 +1,28 @@
 from datetime import date
 from os import path
 
+import beangulp
 import requests
 import yaml
 from beancount.core import amount, data
 from beancount.core.number import D
-from beancount.ingest import importer
 
 
 class HttpServiceException(Exception):
     pass
 
 
-class Importer(importer.ImporterProtocol):
+class Importer(beangulp.Importer):
     """An importer for Nordigen API (e.g. for Revolut)."""
 
-    def identify(self, file):
-        return path.basename(file.name).endswith("nordigen.yaml")
+    def identify(self, filepath: str) -> bool:
+        return path.basename(filepath).endswith("nordigen.yaml")
 
-    def file_account(self, file):
+    def account(self, filepath: str) -> data.Entries:
         return ""
 
-    def extract(self, file, existing_entries):
-        with open(file.name, "r") as f:
+    def extract(self, filepath: str, existing: data.Entries) -> data.Entries:
+        with open(filepath, "r") as f:
             config = yaml.safe_load(f)
 
         r = requests.post(
@@ -57,9 +57,13 @@ class Importer(importer.ImporterProtocol):
                 r.json()["transactions"]["booked"], key=lambda trx: trx["bookingDate"]
             )
             for trx in transactions:
-                metakv = {
-                    "nordref": trx["transactionId"],
-                }
+                if "transactionId" in trx:
+                    metakv = {
+                        "nordref": trx["transactionId"],
+                    }
+                else:
+                    metakv = {}
+
                 if "creditorName" in trx:
                     metakv["creditorName"] = trx["creditorName"]
                 if "debtorName" in trx:

tariochbctools/importers/nordigen/nordigen_config.py

@@ -1,21 +1,22 @@
 import argparse
 import sys
+from typing import Any
 
 import requests
 
 
-def build_header(token):
+def build_header(token: str) -> dict[str, str]:
     return {"Authorization": "Bearer " + token}
 
 
-def check_result(result):
+def check_result(result: requests.Response) -> None:
     try:
         result.raise_for_status()
     except requests.exceptions.HTTPError as e:
         raise Exception(e, e.response.text)
 
 
-def get_token(secret_id, secret_key):
+def get_token(secret_id: str, secret_key: str) -> str:
     r = requests.post(
         "https://bankaccountdata.gocardless.com/api/v2/token/new/",
         data={
@@ -28,7 +29,7 @@ def get_token(secret_id, secret_key):
     return r.json()["access"]
 
 
-def list_bank(token, country):
+def list_bank(token: str, country: str) -> None:
     r = requests.get(
         "https://bankaccountdata.gocardless.com/api/v2/institutions/",
         params={"country": country},
@@ -40,7 +41,7 @@ def list_bank(token, country):
         print(asp["name"] + ": " + asp["id"])  # noqa: T201
 
 
-def create_link(token, reference, bank):
+def create_link(token: str, reference: str, bank: str) -> None:
     if not bank:
         raise Exception("Please specify --bank it is required for create_link")
     requisitionId = _find_requisition_id(token, reference)
@@ -61,7 +62,7 @@ def create_link(token, reference, bank):
         print(f"Go to {link} for connecting to your bank.")  # noqa: T201
 
 
-def list_accounts(token):
+def list_accounts(token: str) -> None:
     headers = build_header(token)
     r = requests.get(
         "https://bankaccountdata.gocardless.com/api/v2/requisitions/", headers=headers
@@ -93,7 +94,7 @@ def list_accounts(token):
             print(f"{account}: {asp} {owner} {iban} {currency}")  # noqa: T201
 
 
-def delete_link(token, reference):
+def delete_link(token: str, reference: str) -> None:
     requisitionId = _find_requisition_id(token, reference)
     if requisitionId:
         r = requests.delete(
@@ -103,7 +104,7 @@ def delete_link(token, reference):
         check_result(r)
 
 
-def _find_requisition_id(token, userId):
+def _find_requisition_id(token: str, userId: str) -> str | None:
     headers = build_header(token)
     r = requests.get(
         "https://bankaccountdata.gocardless.com/api/v2/requisitions/", headers=headers
@@ -116,7 +117,7 @@ def _find_requisition_id(token, userId):
     return None
 
 
-def parse_args(args):
+def parse_args(args: Any) -> Any:
     parser = argparse.ArgumentParser(description="nordigen-config")
     parser.add_argument(
         "--secret_id",
@@ -154,7 +155,7 @@ def parse_args(args):
     return parser.parse_args(args)
 
 
-def main(args):
+def main(args: Any) -> None:
     args = parse_args(args)
 
     token = get_token(args.secret_id, args.secret_key)
@@ -169,6 +170,6 @@ def main(args):
         delete_link(token, args.reference)
 
 
-def run():
+def run() -> None:
     """Entry point for console_scripts"""
     main(sys.argv[1:])

tariochbctools/importers/postfinance/importer.py

@@ -1,49 +1,52 @@
 import csv
 import logging
+import re
 from datetime import datetime, timedelta
 from decimal import Decimal
 
+import beangulp
 from beancount.core import data
-from beancount.ingest.importer import ImporterProtocol
-from beancount.ingest.importers.mixins.identifier import IdentifyMixin
 
 
-class Importer(IdentifyMixin, ImporterProtocol):
+class Importer(beangulp.Importer):
     """An importer for PostFinance CSV."""
 
-    def __init__(self, regexps, account, currency="CHF"):
-        IdentifyMixin.__init__(self, matchers=[("filename", regexps)])
-        self.account = account
+    def __init__(self, filepattern: str, account: data.Account, currency: str = "CHF"):
+        self._filepattern = filepattern
+        self._account = account
         self.currency = currency
 
-    def file_account(self, file):
-        return self.account
+    def identify(self, filepath: str) -> bool:
+        return re.search(self._filepattern, filepath) is not None
 
-    def extract(self, file, existing_entries):
-        csvfile = open(file=file.name, encoding="windows_1252")
+    def account(self, filepath: str) -> data.Account:
+        return self._account
+
+    def extract(self, filepath: str, existing: data.Entries) -> data.Entries:
+        csvfile = open(file=filepath, encoding="windows_1252")
         reader = csv.reader(csvfile, delimiter=";")
-        meta = data.new_metadata(file.name, 0)
+        meta = data.new_metadata(filepath, 0)
         entries = []
 
         for row in reader:
             try:
-                book_date, text, credit, debit, val_date, balance = tuple(row)
-                book_date = datetime.strptime(book_date, "%Y-%m-%d").date()
+                book_date_str, text, credit, debit, val_date, balance_str = tuple(row)
+                book_date = datetime.strptime(book_date_str, "%Y-%m-%d").date()
                 if credit:
                     amount = data.Amount(Decimal(credit), self.currency)
                 elif debit:
                     amount = data.Amount(Decimal(debit), self.currency)
                 else:
                     amount = None
-                if balance:
-                    balance = data.Amount(Decimal(balance), self.currency)
+                if balance_str:
+                    balance = data.Amount(Decimal(balance_str), self.currency)
                 else:
                     balance = None
             except Exception as e:
                 logging.debug(e)
             else:
                 logging.debug((book_date, text, amount, val_date, balance))
-                posting = data.Posting(self.account, amount, None, None, None, None)
+                posting = data.Posting(self._account, amount, None, None, None, None)
                 entry = data.Transaction(
                     meta,
                     book_date,
@@ -59,7 +62,7 @@ class Importer(IdentifyMixin, ImporterProtocol):
                 book_date = book_date + timedelta(days=1)
                 if balance and book_date.day == 1:
                     entry = data.Balance(
-                        meta, book_date, self.account, balance, None, None
+                        meta, book_date, self._account, balance, None, None
                     )
                     entries.append(entry)
 

tariochbctools/importers/quickfile/importer.py

@@ -5,11 +5,11 @@ from hashlib import md5
 from os import path
 from typing import Dict, List, NamedTuple
 
+import beangulp
 import requests
 import yaml
 from beancount.core import amount, data
 from beancount.core.number import D
-from beancount.ingest import importer
 from undictify import type_checked_constructor
 
 
@@ -152,32 +152,32 @@ class QuickFile:
         return QuickFileBankSearch(**body)
 
 
-class Importer(importer.ImporterProtocol):
+class Importer(beangulp.Importer):
     """An importer for QuickFile"""
 
     def __init__(self):
         self.quickfile = None
         self.config = None
-        self.existing_entries = None
+        self.existing = None
 
-    def _configure(self, file, existing_entries):
-        with open(file.name, "r") as config_file:
+    def _configure(self, filepath, existing):
+        with open(filepath, "r") as config_file:
             self.config = yaml.safe_load(config_file)
             self.quickfile = QuickFile(
                 account_number=self.config["account_number"],
                 api_key=self.config["api_key"],
                 app_id=self.config["app_id"],
             )
-        self.existing_entries = existing_entries
+        self.existing = existing
 
-    def identify(self, file):
-        return path.basename(file.name) == "quickfile.yaml"
+    def identify(self, filepath):
+        return path.basename(filepath) == "quickfile.yaml"
 
-    def file_account(self, file):
+    def account(self, filepath):
         return ""
 
-    def extract(self, file, existing_entries=None):
-        self._configure(file, existing_entries)
+    def extract(self, filepath, existing=None):
+        self._configure(filepath, existing)
         entries = []
 
         for bank_account in self.config["accounts"].keys():

tariochbctools/importers/raiffeisench/importer.py

@@ -1,4 +1,5 @@
 import re
+from typing import Any
 
 from tariochbctools.importers.general import mt940importer
 
@@ -8,21 +9,16 @@ class RaiffeisenCHImporter(mt940importer.Importer):
 
     """To get the correct file, choose SWIFT -> 'Période prédéfinie du relevé de compte' -> Sans détails"""
 
-    def prepare_payee(self, trxdata):
+    def prepare_payee(self, trxdata: dict[str, Any]) -> str:
         return ""
 
-    def prepare_narration(self, trxdata):
+    def prepare_narration(self, trxdata: dict[str, Any]) -> str:
         extra = trxdata["extra_details"]
         details = trxdata["transaction_details"]
 
-        extraReplacements = {}
-
         detailsReplacements = {}
         detailsReplacements[r"\n"] = ", "
 
-        for pattern, replacement in extraReplacements.items():
-            extra = re.sub(pattern, replacement, extra)
-
         for pattern, replacement in detailsReplacements.items():
             details = re.sub(pattern, replacement, details)
 

tariochbctools/importers/revolut/importer.py

@@ -1,34 +1,39 @@
 import csv
 import logging
+import re
 from datetime import timedelta
-from io import StringIO
+from typing import Any
 
+import beangulp
 from beancount.core import amount, data
 from beancount.core.number import ZERO, D
-from beancount.ingest import importer
-from beancount.ingest.importers.mixins import identifier
 from dateutil.parser import parse
 
 
-class Importer(identifier.IdentifyMixin, importer.ImporterProtocol):
+class Importer(beangulp.Importer):
     """An importer for Revolut CSV files."""
 
-    def __init__(self, regexps, account, currency, fee=None):
-        identifier.IdentifyMixin.__init__(self, matchers=[("filename", regexps)])
-        self.account = account
+    def __init__(
+        self, filepattern: str, account: data.Account, currency: str, fee: Any = None
+    ):
+        self._filepattern = filepattern
+        self._account = account
         self.currency = currency
         self._fee = fee
 
-    def name(self):
-        return super().name() + self.account
+    def name(self) -> str:
+        return super().name() + self._account
 
-    def file_account(self, file):
-        return self.account
+    def identify(self, filepath: str) -> bool:
+        return re.search(self._filepattern, filepath) is not None
 
-    def extract(self, file, existing_entries):
+    def account(self, filepath: str) -> data.Account:
+        return self._account
+
+    def extract(self, filepath: str, existing: data.Entries) -> data.Entries:
         entries = []
 
-        with StringIO(file.contents()) as csvfile:
+        with open(filepath) as csvfile:
             reader = csv.DictReader(
                 csvfile,
                 [
@@ -65,12 +70,12 @@ class Importer(identifier.IdentifyMixin, importer.ImporterProtocol):
                     continue
 
                 postings = [
-                    data.Posting(self.account, amt, None, None, None, None),
+                    data.Posting(self._account, amt, None, None, None, None),
                 ]
                 description = row["Description"].strip()
                 if is_fee_mode:
                     postings = [
-                        data.Posting(self.account, fee, None, None, None, None),
+                        data.Posting(self._account, fee, None, None, None, None),
                         data.Posting(
                             self._fee["account"], -fee, None, None, None, None
                         ),
@@ -82,7 +87,7 @@ class Importer(identifier.IdentifyMixin, importer.ImporterProtocol):
                 ), "Actual type of description is " + str(type(description))
 
                 entry = data.Transaction(
-                    data.new_metadata(file.name, 0, {}),
+                    data.new_metadata(filepath, 0, {}),
                     book_date,
                     "*",
                     "",
@@ -98,9 +103,9 @@ class Importer(identifier.IdentifyMixin, importer.ImporterProtocol):
                 try:
                     book_date = book_date + timedelta(days=1)
                     entry = data.Balance(
-                        data.new_metadata(file.name, 0, {}),
+                        data.new_metadata(filepath, 0, {}),
                         book_date,
-                        self.account,
+                        self._account,
                         balance,
                         None,
                         None,

tariochbctools/importers/schedule/importer.py

@@ -1,24 +1,25 @@
 import datetime
 from os import path
+from typing import Any
 
+import beangulp
 import yaml
 from beancount.core import amount, data
 from beancount.core.number import D
-from beancount.ingest import importer
 from dateutil.relativedelta import relativedelta
 
 
-class Importer(importer.ImporterProtocol):
+class Importer(beangulp.Importer):
     """An importer for Scheduled/Recurring Transactions."""
 
-    def identify(self, file):
-        return path.basename(file.name).endswith("schedule.yaml")
+    def identify(self, filepath: str) -> bool:
+        return path.basename(filepath).endswith("schedule.yaml")
 
-    def file_account(self, file):
+    def account(self, filepath: str) -> data.Account:
         return ""
 
-    def extract(self, file, existing_entries):
-        with open(file.name, "r") as f:
+    def extract(self, filepath: str, existing: data.Entries) -> data.Entries:
+        with open(filepath, "r") as f:
             config = yaml.safe_load(f)
         self.transactions = config["transactions"]
 
@@ -30,7 +31,9 @@ class Importer(importer.ImporterProtocol):
 
         return result
 
-    def createForDate(self, trx, date):
+    def createForDate(
+        self, trx: dict[str, Any], date: datetime.date
+    ) -> data.Transaction:
         postings = []
         for post in trx["postings"]:
             amt = None

tariochbctools/importers/swisscard/importer.py

@@ -1,29 +1,31 @@
 import csv
-from io import StringIO
+import re
 
 from beancount.core import amount, data
 from beancount.core.number import D
-from beancount.ingest import importer
-from beancount.ingest.importers.mixins import identifier
+from beangulp import Importer
 from dateutil.parser import parse
 
 
-class SwisscardImporter(identifier.IdentifyMixin, importer.ImporterProtocol):
+class SwisscardImporter(Importer):
     """An importer for Swisscard's cashback CSV files."""
 
-    def __init__(self, regexps, account):
-        identifier.IdentifyMixin.__init__(self, matchers=[("filename", regexps)])
-        self.account = account
+    def __init__(self, filepattern: str, account: data.Account):
+        self._filepattern = filepattern
+        self._account = account
 
-    def name(self):
-        return super().name() + self.account
+    def name(self) -> str:
+        return super().name() + self._account
 
-    def file_account(self, file):
-        return self.account
+    def identify(self, filepath: str) -> bool:
+        return re.search(self._filepattern, filepath) is not None
 
-    def extract(self, file, existing_entries):
+    def account(self, filepath: str) -> data.Account:
+        return self._account
+
+    def extract(self, filepath: str, existing: data.Entries) -> data.Entries:
         entries = []
-        with StringIO(file.contents()) as csvfile:
+        with open(filepath) as csvfile:
             reader = csv.DictReader(
                 csvfile,
                 delimiter=",",
@@ -36,7 +38,7 @@ class SwisscardImporter(identifier.IdentifyMixin, importer.ImporterProtocol):
                     "merchant": row["Merchant Category"],
                     "category": row["Registered Category"],
                 }
-                meta = data.new_metadata(file.name, 0, metakv)
+                meta = data.new_metadata(filepath, 0, metakv)
                 description = row["Description"].strip()
                 entry = data.Transaction(
                     meta,
@@ -47,7 +49,7 @@ class SwisscardImporter(identifier.IdentifyMixin, importer.ImporterProtocol):
                     data.EMPTY_SET,
                     data.EMPTY_SET,
                     [
-                        data.Posting(self.account, amt, None, None, None, None),
+                        data.Posting(self._account, amt, None, None, None, None),
                     ],
                 )
                 entries.append(entry)