beancount-gocardless 0.1.13__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)
@@ -477,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()

beancount_gocardless/models.py

@@ -37,8 +37,10 @@ class StatusEnum(str, Enum):
 class BalanceAmountSchema(BaseModel):
     """Balance amount schema."""
 
-    amount: str
-    currency: str
+    model_config = ConfigDict(populate_by_name=True)
+
+    amount: str = Field(default=None)
+    currency: str = Field(default=None)
 
 
 class BalanceSchema(BaseModel):
@@ -198,10 +200,12 @@ class CurrencyExchangeSchema(BaseModel):
 class BalanceAfterTransactionSchema(BaseModel):
     """Balance after transaction schema."""
 
-    model_config = ConfigDict(alias_generator=to_camel, populate_by_name=True)
+    model_config = ConfigDict(populate_by_name=True)
 
-    balance_after_transaction: Optional[BalanceAmountSchema] = None
-    balance_type: Optional[str] = None
+    balance_amount: Optional[BalanceAmountSchema] = Field(
+        default=None, validation_alias="balanceAmount"
+    )
+    balance_type: Optional[str] = Field(default=None, validation_alias="balanceType")
 
 
 class TransactionSchema(BaseModel):
@@ -280,6 +284,9 @@ class BankTransaction(BaseModel):
     )
     creditor_name: Optional[str] = Field(None, description="Creditor name.")
     creditor_account: Optional[AccountSchema] = None
+    ultimate_creditor: Optional[str] = Field(
+        default=None, description="Ultimate creditor."
+    )
     currency_exchange: Optional[List[CurrencyExchangeSchema]] = None
 
     @field_validator("currency_exchange", mode="before")
@@ -308,11 +315,13 @@ class BankTransaction(BaseModel):
     booking_date_time: Optional[str] = Field(None, description="Booking date and time.")
     value_date_time: Optional[str] = Field(None, description="Value date and time.")
     entry_reference: Optional[str] = Field(None, description="Entry reference.")
-    additional_information_structured: Optional[str] = Field(
-        None, description="Additional structured information."
+    additional_data_structured: Optional[Dict[str, Any]] = Field(
+        default=None,
+        description="Additional structured information.",
     )
     card_transaction: Optional[Dict[str, Any]] = Field(
-        None, description="Card transaction details."
+        default=None,
+        description="Card transaction details.",
     )
     merchant_category_code: Optional[str] = Field(
         None, description="Merchant category code."
@@ -576,6 +585,8 @@ class AccountConfig(BaseModel):
     metadata: Dict[str, Any] = {}
     transaction_types: List[str] = ["booked", "pending"]
     preferred_balance_type: Optional[str] = None
+    exclude_default_metadata: List[str] = []
+    metadata_fields: Optional[Dict[str, str]] = None
 
     @field_validator("transaction_types")
     @classmethod

beancount_gocardless/utils.py

@@ -0,0 +1,39 @@
+import os
+from pathlib import Path
+from typing import Optional
+
+
+def load_dotenv(dotenv_path: Optional[str] = None) -> None:
+    """
+    Simple .env loader that searches in current and parent directories.
+    Only handles simple KEY=VALUE pairs and ignores comments.
+    """
+    if dotenv_path:
+        search_paths = [Path(dotenv_path)]
+    else:
+        # Search in current and parent directories
+        current = Path.cwd().resolve()
+        search_paths = [current / ".env"] + [p / ".env" for p in current.parents]
+
+    for path in search_paths:
+        if path.exists() and path.is_file():
+            try:
+                with open(path, "r") as f:
+                    for line in f:
+                        line = line.strip()
+                        # Ignore comments and empty lines
+                        if not line or line.startswith("#"):
+                            continue
+                        # Basic KEY=VALUE parsing
+                        if "=" in line:
+                            key, value = line.split("=", 1)
+                            key = key.strip()
+                            # Strip quotes and whitespace
+                            value = value.strip().strip("'\"")
+                            # Only set if not already present in environment
+                            if key and key not in os.environ:
+                                os.environ[key] = value
+                return  # Stop after the first .env file found and successfully read
+            except Exception:
+                # Silently fail if we can't read a specific .env file
+                continue