beancount-gocardless 0.1.12__py3-none-any.whl → 0.1.14__py3-none-any.whl

beancount_gocardless/client.py

@@ -404,17 +404,30 @@ class GoCardlessClient:
 
     def get_all_accounts(self) -> List[AccountInfo]:
         """Get all accounts from all requisitions"""
+        from datetime import datetime, timedelta
+
         accounts = []
         for req in self.get_requisitions():
             for account_id in req.accounts:
                 try:
                     account = self.get_account(account_id)
                     account_dict = account.model_dump()
+
+                    access_valid_days = req.access_valid_for_days or 90
+                    created_date = datetime.fromisoformat(
+                        req.created.replace("Z", "+00:00")
+                    )
+                    expiry_date = created_date + timedelta(days=access_valid_days)
+                    is_expired = req.status == "EX"
+
                     account_dict.update(
                         {
                             "requisition_id": req.id,
                             "requisition_reference": req.reference,
                             "institution_id": req.institution_id,
+                            "requisition_status": req.status,
+                            "access_valid_until": expiry_date.isoformat(),
+                            "is_expired": is_expired,
                         }
                     )
                     accounts.append(account_dict)

beancount_gocardless/importer.py

@@ -8,11 +8,23 @@ from beancount.core import amount, data, flags
 from beancount.core.number import D
 
 from .client import GoCardlessClient
-from .models import BankTransaction, GoCardlessConfig
+from .models import BankTransaction, GoCardlessConfig, AccountConfig
 
 logger = logging.getLogger(__name__)
 
 
+def _flatten_dict(d: Dict[str, Any], prefix: str = "") -> Dict[str, Any]:
+    """Recursively flatten a nested dict to dotted paths."""
+    result: Dict[str, Any] = {}
+    for key, value in d.items():
+        new_key = f"{prefix}.{key}" if prefix else key
+        if isinstance(value, dict):
+            result.update(_flatten_dict(value, new_key))
+        else:
+            result[new_key] = value
+    return result
+
+
 class ReferenceDuplicatesComparator:
     def __init__(self, refs: List[str] = ["ref"]) -> None:
         self.refs = refs
@@ -38,6 +50,13 @@ class GoCardLessImporter(beangulp.Importer):
         _client (Optional[GoCardlessClient]): Instance of the GoCardless API client.
     """
 
+    DEFAULT_METADATA_FIELDS: Dict[str, str] = {
+        "nordref": "transactionId",
+        "creditorName": "creditorName",
+        "debtorName": "debtorName",
+        "bookingDate": "bookingDate",
+    }
+
     def __init__(self) -> None:
         """Initialize the GoCardLessImporter."""
         logger.debug("Initializing GoCardLessImporter")
@@ -136,47 +155,45 @@ class GoCardLessImporter(beangulp.Importer):
         )
 
     def add_metadata(
-        self, transaction: BankTransaction, custom_metadata: Dict[str, Any]
+        self,
+        transaction: BankTransaction,
+        custom_metadata: Dict[str, Any],
+        account_config: Optional[AccountConfig] = None,
     ) -> Dict[str, Any]:
-        """
-        Extracts metadata from a transaction and returns it as a dictionary.
-
-        This method can be overridden in subclasses to customize metadata extraction.
-
-        Args:
-            transaction (BankTransaction): The transaction data from the API.
-            custom_metadata (Dict[str, Any]): Custom metadata from the config file.
-
-        Returns:
-            Dict[str, Any]: A dictionary of metadata key-value pairs.
-        """
         metakv: Dict[str, Any] = {}
 
-        # Transaction ID
-        if transaction.transaction_id:
-            metakv["nordref"] = transaction.transaction_id
-
-        # Names
-        if transaction.creditor_name:
-            metakv["creditorName"] = transaction.creditor_name
-        if transaction.debtor_name:
-            metakv["debtorName"] = transaction.debtor_name
-
-        # Currency exchange
-        if (
-            transaction.currency_exchange
-            and transaction.currency_exchange[0].instructed_amount
-        ):
-            instructedAmount = transaction.currency_exchange[0].instructed_amount
-            metakv["original"] = (
-                f"{instructedAmount.currency} {instructedAmount.amount}"
-            )
-
-        if transaction.booking_date:
-            metakv["bookingDate"] = transaction.booking_date
+        exclude_fields: List[str] = []
+        custom_fields: Dict[str, str] = {}
+
+        if account_config is not None:
+            exclude_fields = account_config.exclude_default_metadata or []
+            custom_fields = account_config.metadata_fields or {}
+
+        # Start with defaults, merge with custom fields
+        fields = dict(self.DEFAULT_METADATA_FIELDS)
+        fields.update(custom_fields)
+
+        # Remove excluded fields
+        for key in exclude_fields:
+            fields.pop(key, None)
+
+        for out_key, gcl_path in fields.items():
+            if gcl_path is None:
+                continue
+            val = self._get_gcl_path(transaction, gcl_path)
+            if val is None:
+                continue
+
+            if (
+                out_key == "original"
+                and hasattr(val, "currency")
+                and hasattr(val, "amount")
+            ):
+                metakv[out_key] = f"{val.currency} {val.amount}"
+            else:
+                metakv[out_key] = val
 
         metakv.update(custom_metadata)
-
         return metakv
 
     def get_narration(self, transaction: BankTransaction) -> str:
@@ -264,6 +281,7 @@ class GoCardLessImporter(beangulp.Importer):
         status: str,
         asset_account: str,
         custom_metadata: Dict[str, Any],
+        account_config: Optional[AccountConfig] = None,
     ) -> Optional[data.Transaction]:
         """
         Creates a Beancount transaction entry from a GoCardless transaction.
@@ -275,6 +293,7 @@ class GoCardLessImporter(beangulp.Importer):
             status (str): The transaction status ('booked' or 'pending').
             asset_account (str): The Beancount asset account.
             custom_metadata (Dict[str, Any]): Custom metadata from config
+            account_config (Optional[AccountConfig]): Account configuration for metadata options.
 
         Returns:
             Optional[data.Transaction]: The created Beancount transaction entry, or None if date is invalid.
@@ -282,7 +301,7 @@ class GoCardLessImporter(beangulp.Importer):
         logger.debug(
             "Creating entry for transaction %s (%s)", transaction.transaction_id, status
         )
-        metakv = self.add_metadata(transaction, custom_metadata)
+        metakv = self.add_metadata(transaction, custom_metadata, account_config)
         meta = data.new_metadata("", 0, metakv)
 
         trx_date = self.get_transaction_date(transaction)
@@ -377,7 +396,7 @@ class GoCardLessImporter(beangulp.Importer):
             skipped = 0
             for transaction, status in all_transactions:
                 entry = self.create_transaction_entry(
-                    transaction, status, asset_account, custom_metadata
+                    transaction, status, asset_account, custom_metadata, account
                 )
                 if entry is not None:
                     entries.append(entry)
@@ -400,36 +419,61 @@ class GoCardLessImporter(beangulp.Importer):
                     for b in balances.balances
                 ],
             )
-            expected_balance = None
-            other_balances = []
-            for bal in balances.balances:
-                if bal.balance_type == "expected":
-                    expected_balance = bal
-                else:
-                    other_balances.append(bal)
 
-            if expected_balance:
+            # Prioritized balance selection
+            PRIORITY = {
+                "expected": 0,
+                "closingBooked": 1,
+                "interimBooked": 2,
+                "interimAvailable": 3,
+                "openingBooked": 4,
+            }
+            if account.preferred_balance_type:
+                PRIORITY[account.preferred_balance_type] = -1
+
+            # Sort balances based on priority, with unknown types at the end
+            sorted_balances = sorted(
+                balances.balances, key=lambda b: PRIORITY.get(b.balance_type, 99)
+            )
+
+            if sorted_balances:
+                selected_balance = sorted_balances[0]
                 balance_amount = amount.Amount(
-                    D(str(expected_balance.balance_amount.amount)),
-                    expected_balance.balance_amount.currency,
+                    D(str(selected_balance.balance_amount.amount)),
+                    selected_balance.balance_amount.currency,
                 )
+
+                # Determine balance date
+                if selected_balance.reference_date:
+                    try:
+                        balance_date = date.fromisoformat(
+                            selected_balance.reference_date
+                        ) + timedelta(days=1)
+                    except ValueError:
+                        balance_date = date.today() + timedelta(days=1)
+                else:
+                    balance_date = date.today() + timedelta(days=1)
+
                 balance_meta = {}
-                balance_amounts = [
-                    D(str(b.balance_amount.amount)) for b in balances.balances
-                ]
-                if len(set(balance_amounts)) > 1:
-                    detail_parts = [
-                        f"{b.balance_type}: {b.balance_amount.amount} {b.balance_amount.currency}"
-                        for b in balances.balances
-                    ]
-                    detail = " / ".join(detail_parts)
-                    balance_meta["detail"] = detail
+
+                # Collect all distinct balance values for metadata
+                distinct_details = []
+                seen_values = set()
+                for b in sorted_balances:
+                    val_str = f"{b.balance_amount.amount} {b.balance_amount.currency}"
+                    if val_str not in seen_values:
+                        distinct_details.append(f"{b.balance_type}: {val_str}")
+                        seen_values.add(val_str)
+
+                balance_meta["detail"] = " / ".join(distinct_details)
+
                 # Include custom metadata from config for consistency with transactions
                 balance_meta.update(custom_metadata)
                 meta = data.new_metadata("", 0, balance_meta)
+
                 balance_entry = data.Balance(
                     meta=meta,
-                    date=date.today() + timedelta(days=1),
+                    date=balance_date,
                     account=asset_account,
                     amount=balance_amount,
                     tolerance=None,
@@ -437,26 +481,13 @@ class GoCardLessImporter(beangulp.Importer):
                 )
                 entries.append(balance_entry)
                 logger.debug(
-                    "Added balance assertion for account %s using expected balance: %s %s",
+                    "Added balance assertion for account %s using %s balance: %s %s",
                     account_id,
+                    selected_balance.balance_type,
                     balance_amount,
-                    date.today() + timedelta(days=1),
+                    balance_date,
                 )
 
-                # Log other balances if they differ from expected
-                expected_amount = D(str(expected_balance.balance_amount.amount))
-                for bal in other_balances:
-                    other_amount = D(str(bal.balance_amount.amount))
-                    if other_amount != expected_amount:
-                        logger.info(
-                            "Account %s has different balance for type %s: %s %s vs expected %s",
-                            account_id,
-                            bal.balance_type,
-                            other_amount,
-                            bal.balance_amount.currency,
-                            expected_amount,
-                        )
-
         logger.info(
             "Processed %d total transactions across %d accounts, created %d entries",
             total_transactions,
@@ -465,4 +496,42 @@ class GoCardLessImporter(beangulp.Importer):
         )
         return entries
 
+    def _get_gcl_path(self, root: Any, dotted: str) -> Any:
+        cur: Any = root
+        for seg in dotted.split("."):
+            if cur is None:
+                return None
+
+            if isinstance(cur, list):
+                if not seg.isdigit():
+                    return None
+                idx = int(seg)
+                if idx >= len(cur):
+                    return None
+                cur = cur[idx]
+                continue
+
+            if isinstance(cur, dict):
+                cur = cur.get(seg)
+                continue
+
+            if hasattr(cur, seg):
+                cur = getattr(cur, seg)
+                continue
+
+            if hasattr(type(cur), "model_fields"):
+                model_fields = type(cur).model_fields
+                name = next(
+                    (n for n, f in model_fields.items() if f.alias == seg), None
+                )
+                if name and hasattr(cur, name):
+                    cur = getattr(cur, name)
+                    continue
+
+            return None
+
+        if isinstance(cur, (dict, list)):
+            return None
+        return cur
+
     cmp = ReferenceDuplicatesComparator(["nordref"])

beancount_gocardless/mock_client.py

@@ -0,0 +1,220 @@
+"""
+Mock client for testing without real API calls.
+Returns synthetic demo data for CLI testing.
+"""
+
+import logging
+from typing import Optional, List, Dict, Any
+from datetime import datetime, timedelta
+
+from .client import GoCardlessClient
+from .models import (
+    Institution,
+    Requisition,
+    Account,
+    AccountBalance,
+    AccountInfo,
+    BalanceSchema,
+    BalanceAmountSchema,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class MockGoCardlessClient(GoCardlessClient):
+    """Mock client that returns synthetic demo data instead of making API calls."""
+
+    def __init__(
+        self,
+        secret_id: str,
+        secret_key: str,
+        cache_options: Optional[Dict[str, Any]] = None,
+    ):
+        """Initialize mock client."""
+        logger.info("Initializing MockGoCardlessClient")
+        self._token = "mock-token"
+        self.secret_id = secret_id
+        self.secret_key = secret_key
+
+    def list_banks(self, country: Optional[str] = None) -> List[str]:
+        """Get bank names."""
+        institutions = self.get_institutions(country)
+        return [inst.name for inst in institutions]
+
+    def get_institutions(self, country: Optional[str] = None) -> List[Institution]:
+        """Get demo institutions."""
+        logger.debug(f"MockClient: Getting institutions for country {country}")
+        institutions = [
+            Institution(
+                id="SOGEFRPP",
+                name="Société Générale",
+                bic="SOGEFRPP",
+                transaction_total_days="730",
+                countries=["FR"],
+                logo=None,
+            ),
+            Institution(
+                id="BNPAFRPP",
+                name="BNP Paribas",
+                bic="BNPAFRPP",
+                transaction_total_days="730",
+                countries=["FR"],
+                logo=None,
+            ),
+            Institution(
+                id="DEUTSCHE",
+                name="Deutsche Bank",
+                bic="DEUTSCH",
+                transaction_total_days="730",
+                countries=["DE"],
+                logo=None,
+            ),
+        ]
+
+        if country:
+            institutions = [i for i in institutions if country in i.countries]
+
+        return institutions
+
+    def get_institution(self, institution_id: str) -> Institution:
+        """Get specific institution."""
+        logger.debug(f"MockClient: Getting institution {institution_id}")
+        institutions = self.get_institutions()
+        for inst in institutions:
+            if inst.id == institution_id:
+                return inst
+        raise ValueError(f"Institution {institution_id} not found")
+
+    def get_requisitions(self) -> List[Requisition]:
+        """Get demo requisitions."""
+        logger.debug("MockClient: Getting requisitions")
+        accounts = self.get_accounts()
+        if not accounts:
+            return []
+
+        requisitions = []
+        references = [
+            "main-checking",
+            "savings-account",
+            "joint-account",
+            "business-account",
+        ]
+
+        for i in range(0, len(accounts), 2):
+            ref_idx = (i // 2) % len(references)
+            requisitions.append(
+                Requisition(
+                    id=f"req_{i}",
+                    created=datetime.now().isoformat(),
+                    redirect="http://localhost",
+                    reference=references[ref_idx],
+                    status="LINKED",
+                    institution_id="SOGEFRPP" if i % 2 == 0 else "BNPAFRPP",
+                    accounts=[acc.id for acc in accounts[i : i + 2]],
+                    access_valid_for_days=90,
+                )
+            )
+        return requisitions
+
+    def get_account(self, account_id: str) -> Account:
+        """Get demo account."""
+        logger.debug(f"MockClient: Getting account {account_id}")
+        accounts = self.get_accounts()
+        for acc in accounts:
+            if acc.id == account_id:
+                return acc
+        raise ValueError(f"Account {account_id} not found")
+
+    def get_accounts(self) -> List[Account]:
+        """Get demo accounts."""
+        return [
+            Account(
+                id="acc_001",
+                created=datetime.now().isoformat(),
+                status="READY",
+                institution_id="SOGEFRPP",
+                name="Main Checking",
+                iban="FR1420041010050500013M02606",
+            ),
+            Account(
+                id="acc_002",
+                created=datetime.now().isoformat(),
+                status="READY",
+                institution_id="BNPAFRPP",
+                name="Savings Account",
+                iban="FR7613807000013000060004391",
+            ),
+        ]
+
+    def get_account_balances(self, account_id: str) -> AccountBalance:
+        """Get demo account balances."""
+        logger.debug(f"MockClient: Getting balances for account {account_id}")
+        return AccountBalance(
+            balances=[
+                BalanceSchema(
+                    balance_amount=BalanceAmountSchema(
+                        amount="2547.83", currency="EUR"
+                    ),
+                    balance_type="interimAvailable",
+                ),
+                BalanceSchema(
+                    balance_amount=BalanceAmountSchema(
+                        amount="2490.00", currency="EUR"
+                    ),
+                    balance_type="closingBooked",
+                ),
+            ]
+        )
+
+    def list_accounts(self) -> List[AccountInfo]:
+        """Get all accounts with expiry info."""
+        logger.debug("MockClient: Getting all accounts")
+        accounts = self.get_accounts()
+        requisitions = self.get_requisitions()
+        result = []
+
+        for i, account in enumerate(accounts):
+            account_dict = account.model_dump()
+            req = requisitions[i // 2] if requisitions else None
+            req_status = req.status if req else "LINKED"
+            req_created = req.created if req else datetime.now().isoformat()
+            req_id = req.id if req else f"mock-req-{i // 2}"
+            req_ref = req.reference if req else f"mock-ref-{i // 2}"
+            access_days = (
+                req.access_valid_for_days if req and req.access_valid_for_days else 90
+            )
+
+            created_date = datetime.fromisoformat(req_created.replace("Z", "+00:00"))
+            expiry_date = created_date + timedelta(days=access_days)
+            is_expired = req_status == "EX"
+
+            account_dict.update(
+                {
+                    "requisition_id": req_id,
+                    "requisition_reference": req_ref,
+                    "institution_id": account.institution_id or "mock-inst",
+                    "requisition_status": req_status,
+                    "access_valid_until": expiry_date.isoformat(),
+                    "is_expired": is_expired,
+                }
+            )
+            result.append(account_dict)
+        return result
+
+    def create_requisition(self, *args, **kwargs):
+        raise NotImplementedError("MockClient does not support creating requisitions")
+
+    def create_bank_link(self, *args, **kwargs):
+        raise NotImplementedError("MockClient does not support creating bank links")
+
+    def delete_requisition(self, *args, **kwargs):
+        raise NotImplementedError("MockClient does not support deleting requisitions")
+
+    def find_requisition_by_reference(self, reference: str) -> Optional[Requisition]:
+        """Find requisition by reference."""
+        requisitions = self.get_requisitions()
+        return next((req for req in requisitions if req.reference == reference), None)
+
+    def get_all_accounts(self) -> List[AccountInfo]:
+        """Alias for list_accounts."""
+        return self.list_accounts()