beancount-gocardless 0.1.11__tar.gz → 0.1.13__tar.gz

{beancount_gocardless-0.1.11 → beancount_gocardless-0.1.13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: beancount-gocardless
-Version: 0.1.11
+Version: 0.1.13
 License-Expression: Unlicense
 License-File: LICENSE
 Requires-Python: <4,>=3.12
@@ -52,30 +52,8 @@ You'll need to create a GoCardLess account on https://bankaccountdata.gocardless
 
 ### API Coverage
 
-The GoCardless client provides **complete API coverage** with Pydantic models for all endpoints and data structures:
-
-**🏦 Core Banking:**
-- **Accounts**: Full account metadata, balances, details, and transactions
-- **Institutions**: Bank/institution information and capabilities
-- **Requisitions**: Bank link management with full lifecycle support
-
-**📋 Agreements & Permissions:**
-- **End User Agreements**: Complete agreement lifecycle management
-- **Access Scopes**: Granular permission control
-- **Reconfirmations**: Agreement renewal workflows
-
-**🔧 Advanced Features:**
-- **Integrations**: Institution capability discovery
-- **Token Management**: JWT token handling (internal)
-- **Pagination**: Full paginated response support
-- **Error Handling**: Error response models
-
-**📊 Rich Data Models:**
-- **Transactions**: Complete transaction details with currency exchange, balances, and metadata
-- **Balances**: Multi-currency balance information with transaction impact
-- **Account Details**: Extensive account information including ownership and addresses
-
-Models manually recreated from the swagger spec, providing type-safe access to every API feature.
+The GoCardless client tries to provide complete API coverage with Pydantic models for all endpoints and data structures.
+Models are manually recreated from the swagger spec, providing type-safe access to every API feature.
 
 **Installation:**
 
@@ -98,7 +76,8 @@ cache_options: # by default, no caching if cache_options is not provided
 accounts:
     - id: <REDACTED_UUID>
       asset_account: "Assets:Banks:Revolut:Checking"
-      transaction_types: ["booked", "pending"]  # optional, defaults to both
+      transaction_types: ["booked", "pending"]  # optional list, defaults to both
+      preferred_balance_type: "interimAvailable"  # optional, use specific balance type
 ```
 
 ```python
@@ -107,20 +86,19 @@ accounts:
 
 import beangulp
 from beancount_gocardless import GoCardLessImporter
-from smart_importer import apply_hooks, PredictPostings, PredictPayees
+from smart_importer import PredictPostings, PredictPayees
 
 importers = [
-    apply_hooks(
-        GoCardLessImporter(),
-        [
-            PredictPostings(),
-            PredictPayees(),
-        ],
-    )
+    GoCardLessImporter()
+]
+
+hooks = [
+    PredictPostings().hook,
+    PredictPayees().hook,
 ]
 
 if __name__ == "__main__":
-    ingest = beangulp.Ingest(importers)
+    ingest = beangulp.Ingest(importers, hooks=hooks)
     ingest()
 ```
 

{beancount_gocardless-0.1.11 → beancount_gocardless-0.1.13}/README.md

@@ -25,30 +25,8 @@ You'll need to create a GoCardLess account on https://bankaccountdata.gocardless
 
 ### API Coverage
 
-The GoCardless client provides **complete API coverage** with Pydantic models for all endpoints and data structures:
-
-**🏦 Core Banking:**
-- **Accounts**: Full account metadata, balances, details, and transactions
-- **Institutions**: Bank/institution information and capabilities
-- **Requisitions**: Bank link management with full lifecycle support
-
-**📋 Agreements & Permissions:**
-- **End User Agreements**: Complete agreement lifecycle management
-- **Access Scopes**: Granular permission control
-- **Reconfirmations**: Agreement renewal workflows
-
-**🔧 Advanced Features:**
-- **Integrations**: Institution capability discovery
-- **Token Management**: JWT token handling (internal)
-- **Pagination**: Full paginated response support
-- **Error Handling**: Error response models
-
-**📊 Rich Data Models:**
-- **Transactions**: Complete transaction details with currency exchange, balances, and metadata
-- **Balances**: Multi-currency balance information with transaction impact
-- **Account Details**: Extensive account information including ownership and addresses
-
-Models manually recreated from the swagger spec, providing type-safe access to every API feature.
+The GoCardless client tries to provide complete API coverage with Pydantic models for all endpoints and data structures.
+Models are manually recreated from the swagger spec, providing type-safe access to every API feature.
 
 **Installation:**
 
@@ -71,7 +49,8 @@ cache_options: # by default, no caching if cache_options is not provided
 accounts:
     - id: <REDACTED_UUID>
       asset_account: "Assets:Banks:Revolut:Checking"
-      transaction_types: ["booked", "pending"]  # optional, defaults to both
+      transaction_types: ["booked", "pending"]  # optional list, defaults to both
+      preferred_balance_type: "interimAvailable"  # optional, use specific balance type
 ```
 
 ```python
@@ -80,20 +59,19 @@ accounts:
 
 import beangulp
 from beancount_gocardless import GoCardLessImporter
-from smart_importer import apply_hooks, PredictPostings, PredictPayees
+from smart_importer import PredictPostings, PredictPayees
 
 importers = [
-    apply_hooks(
-        GoCardLessImporter(),
-        [
-            PredictPostings(),
-            PredictPayees(),
-        ],
-    )
+    GoCardLessImporter()
+]
+
+hooks = [
+    PredictPostings().hook,
+    PredictPayees().hook,
 ]
 
 if __name__ == "__main__":
-    ingest = beangulp.Ingest(importers)
+    ingest = beangulp.Ingest(importers, hooks=hooks)
     ingest()
 ```
 

{beancount_gocardless-0.1.11 → beancount_gocardless-0.1.13}/docs/importer.rst

@@ -23,6 +23,8 @@ YAML file:
   - id: Account ID
   - asset_account: Beancount asset account
   - filing_account (opt): For hooks
+  - preferred_balance_type (opt): Preferred type for balance assertions, availability depends on the bank (e.g. "expected", "closingBooked", "interimBooked", "interimAvailable", "available", "booked")
+  - transaction_types (opt): List of types to fetch ("booked" and/or "pending")
 
 Usage
 -----
@@ -44,17 +46,26 @@ Example
     accounts:
         - id: <REDACTED_UUID>
           asset_account: "Assets:Banks:Revolut:Checking"
+          preferred_balance_type: "expected"
+          transaction_types: ["booked", "pending"]
 
 .. code-block:: python
 
     import beangulp
     from beancount_gocardless import GoCardLessImporter
-    from smart_importer import apply_hooks, PredictPostings, PredictPayees
+    from smart_importer import PredictPostings, PredictPayees
 
-    importers = [apply_hooks(GoCardLessImporter(), [PredictPostings(), PredictPayees()])]
+    importers = [
+        GoCardLessImporter()
+    ]
+
+    hooks = [
+        PredictPostings().hook,
+        PredictPayees().hook,
+    ]
 
     if __name__ == "__main__":
-        ingest = beangulp.Ingest(importers)
+        ingest = beangulp.Ingest(importers, hooks=hooks)
         ingest()
 
 .. code-block:: bash

{beancount_gocardless-0.1.11 → beancount_gocardless-0.1.13}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "beancount-gocardless"
-version = "0.1.11"
+version = "0.1.13"
 description = ""
 authors = []
 readme = "README.md"

{beancount_gocardless-0.1.11 → beancount_gocardless-0.1.13}/src/beancount_gocardless/importer.py

@@ -400,32 +400,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 = {}
-                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,
@@ -433,26 +462,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,

{beancount_gocardless-0.1.11 → beancount_gocardless-0.1.13}/src/beancount_gocardless/models.py

@@ -4,7 +4,7 @@ Complete coverage of all schemas from swagger.json
 """
 
 from typing import Optional, List, Dict, Any, TypedDict
-from pydantic import BaseModel, Field, ConfigDict, validator
+from pydantic import BaseModel, Field, ConfigDict, field_validator
 from pydantic.alias_generators import to_camel
 from enum import Enum
 
@@ -166,6 +166,8 @@ class AccountDetail(BaseModel):
 class TransactionAmountSchema(BaseModel):
     """Transaction amount schema."""
 
+    model_config = ConfigDict(alias_generator=to_camel, populate_by_name=True)
+
     amount: str
     currency: str
 
@@ -173,6 +175,8 @@ class TransactionAmountSchema(BaseModel):
 class InstructedAmount(BaseModel):
     """Instructed amount schema."""
 
+    model_config = ConfigDict(alias_generator=to_camel, populate_by_name=True)
+
     amount: str
     currency: str
 
@@ -180,6 +184,8 @@ class InstructedAmount(BaseModel):
 class CurrencyExchangeSchema(BaseModel):
     """Currency exchange schema."""
 
+    model_config = ConfigDict(alias_generator=to_camel, populate_by_name=True)
+
     source_currency: str
     exchange_rate: Optional[str] = None
     unit_currency: Optional[str] = None
@@ -192,6 +198,8 @@ class CurrencyExchangeSchema(BaseModel):
 class BalanceAfterTransactionSchema(BaseModel):
     """Balance after transaction schema."""
 
+    model_config = ConfigDict(alias_generator=to_camel, populate_by_name=True)
+
     balance_after_transaction: Optional[BalanceAmountSchema] = None
     balance_type: Optional[str] = None
 
@@ -206,6 +214,19 @@ class TransactionSchema(BaseModel):
     value_date_time: Optional[str] = Field(None, description="Value date and time.")
     transaction_amount: TransactionAmountSchema
     currency_exchange: Optional[List[CurrencyExchangeSchema]] = None
+
+    model_config = ConfigDict(alias_generator=to_camel, populate_by_name=True)
+
+    @field_validator("currency_exchange", mode="before")
+    @classmethod
+    def normalize_currency_exchange(cls, v):
+        """Normalize currency_exchange to always be a list."""
+        if v is None:
+            return None
+        if isinstance(v, dict):
+            return [v]
+        return v
+
     creditor_name: Optional[str] = Field(None, description="Creditor name.")
     creditor_account: Optional[AccountSchema] = None
     creditor_agent: Optional[str] = Field(None, description="Creditor agent.")
@@ -260,6 +281,17 @@ class BankTransaction(BaseModel):
     creditor_name: Optional[str] = Field(None, description="Creditor name.")
     creditor_account: Optional[AccountSchema] = None
     currency_exchange: Optional[List[CurrencyExchangeSchema]] = None
+
+    @field_validator("currency_exchange", mode="before")
+    @classmethod
+    def normalize_currency_exchange(cls, v):
+        """Normalize currency_exchange to always be a list."""
+        if v is None:
+            return None
+        if isinstance(v, dict):
+            return [v]
+        return v
+
     balance_after_transaction: Optional[BalanceAfterTransactionSchema] = None
     bank_transaction_code: Optional[str] = Field(
         None, description="Bank transaction code."
@@ -543,8 +575,10 @@ class AccountConfig(BaseModel):
     asset_account: str
     metadata: Dict[str, Any] = {}
     transaction_types: List[str] = ["booked", "pending"]
+    preferred_balance_type: Optional[str] = None
 
-    @validator("transaction_types")
+    @field_validator("transaction_types")
+    @classmethod
     def validate_transaction_types(cls, v):
         allowed = {"booked", "pending"}
         if not set(v).issubset(allowed):

beancount_gocardless-0.1.13/tests/test_importer.py

@@ -0,0 +1,150 @@
+import pytest
+from unittest.mock import Mock, patch
+from datetime import date, timedelta
+from beancount.core import data
+from beancount_gocardless.importer import GoCardLessImporter
+from beancount_gocardless.models import (
+    AccountBalance,
+    BalanceSchema,
+    BalanceAmountSchema,
+)
+
+
+@pytest.fixture
+def importer():
+    imp = GoCardLessImporter()
+    imp.config = Mock()
+    imp.config.secret_id = "test_id"
+    imp.config.secret_key = "test_key"
+    imp.config.cache_options = {}
+
+    mock_account = Mock()
+    mock_account.id = "ACC1"
+    mock_account.asset_account = "Assets:Bank:Test"
+    mock_account.metadata = {"test": "meta"}
+    mock_account.transaction_types = ["booked"]
+
+    imp.config.accounts = [mock_account]
+    return imp
+
+
+def test_extract_balance_assertion_priority(importer):
+    """Test that balance assertion uses prioritized types."""
+    with patch("beancount_gocardless.importer.GoCardlessClient") as mock_client_cls:
+        mock_client = mock_client_cls.return_value
+
+        # Mock transactions (empty)
+        mock_tx_resp = Mock()
+        mock_tx_resp.transactions = {"booked": []}
+        mock_client.get_account_transactions.return_value = mock_tx_resp
+
+        # Mock balances - no 'expected', but has 'interimAvailable'
+        mock_balances = AccountBalance(
+            balances=[
+                BalanceSchema(
+                    balance_amount=BalanceAmountSchema(amount="100.00", currency="EUR"),
+                    balance_type="interimAvailable",
+                    reference_date="2026-01-15",
+                )
+            ]
+        )
+        mock_client.get_account_balances.return_value = mock_balances
+
+        # We need to set the internal client to our mock
+        importer._client = mock_client
+        importer.load_config = Mock()
+
+        entries = importer.extract("gocardless.yaml", [])
+
+        # Should have one entry: the balance assertion
+        balance_entries = [e for e in entries if isinstance(e, data.Balance)]
+        assert len(balance_entries) == 1
+        assert balance_entries[0].account == "Assets:Bank:Test"
+        assert balance_entries[0].amount.number == 100
+        # Date should be reference_date + 1 day
+        assert balance_entries[0].date == date(2026, 1, 16)
+        assert balance_entries[0].meta["test"] == "meta"
+        assert "interimAvailable: 100.00 EUR" in balance_entries[0].meta["detail"]
+
+
+def test_extract_balance_assertion_multiple_distinct(importer):
+    """Test that balance assertion shows all distinct balance values."""
+    with patch("beancount_gocardless.importer.GoCardlessClient") as mock_client_cls:
+        mock_client = mock_client_cls.return_value
+        mock_tx_resp = Mock()
+        mock_tx_resp.transactions = {"booked": []}
+        mock_client.get_account_transactions.return_value = mock_tx_resp
+
+        # Multiple balances with different values
+        mock_balances = AccountBalance(
+            balances=[
+                BalanceSchema(
+                    balance_amount=BalanceAmountSchema(amount="100.00", currency="EUR"),
+                    balance_type="expected",
+                    reference_date="2026-01-15",
+                ),
+                BalanceSchema(
+                    balance_amount=BalanceAmountSchema(amount="105.00", currency="EUR"),
+                    balance_type="interimAvailable",
+                    reference_date="2026-01-15",
+                ),
+                BalanceSchema(
+                    balance_amount=BalanceAmountSchema(amount="100.00", currency="EUR"),
+                    balance_type="closingBooked",
+                    reference_date="2026-01-15",
+                ),
+            ]
+        )
+        mock_client.get_account_balances.return_value = mock_balances
+        importer._client = mock_client
+        importer.load_config = Mock()
+
+        entries = importer.extract("gocardless.yaml", [])
+
+        balance_entries = [e for e in entries if isinstance(e, data.Balance)]
+        assert len(balance_entries) == 1
+        assert balance_entries[0].amount.number == 100
+        # Detail should contain expected and interimAvailable, but NOT closingBooked (as it has same value as expected)
+        detail = balance_entries[0].meta["detail"]
+        assert "expected: 100.00 EUR" in detail
+        assert "interimAvailable: 105.00 EUR" in detail
+        assert "closingBooked" not in detail
+
+
+def test_extract_balance_assertion_preferred(importer):
+    """Test that balance assertion respects preferred_balance_type."""
+    with patch("beancount_gocardless.importer.GoCardlessClient") as mock_client_cls:
+        mock_client = mock_client_cls.return_value
+        mock_tx_resp = Mock()
+        mock_tx_resp.transactions = {"booked": []}
+        mock_client.get_account_transactions.return_value = mock_tx_resp
+
+        # Multiple balances, interimAvailable is preferred
+        mock_balances = AccountBalance(
+            balances=[
+                BalanceSchema(
+                    balance_amount=BalanceAmountSchema(amount="100.00", currency="EUR"),
+                    balance_type="expected",
+                    reference_date="2026-01-15",
+                ),
+                BalanceSchema(
+                    balance_amount=BalanceAmountSchema(amount="105.00", currency="EUR"),
+                    balance_type="interimAvailable",
+                    reference_date="2026-01-15",
+                ),
+            ]
+        )
+        mock_client.get_account_balances.return_value = mock_balances
+        importer._client = mock_client
+        importer.load_config = Mock()
+
+        # Set preferred balance type in config
+        importer.config.accounts[0].preferred_balance_type = "interimAvailable"
+
+        entries = importer.extract("gocardless.yaml", [])
+
+        balance_entries = [e for e in entries if isinstance(e, data.Balance)]
+        assert len(balance_entries) == 1
+        # Should use interimAvailable (105.00) even though expected (100.00) exists
+        assert balance_entries[0].amount.number == 105
+        assert "interimAvailable: 105.00 EUR" in balance_entries[0].meta["detail"]

beancount_gocardless-0.1.13/tests/test_models.py

@@ -0,0 +1,147 @@
+import pytest
+from beancount_gocardless.models import (
+    AccountTransactions,
+    BankTransaction,
+    TransactionSchema,
+)
+
+
+def test_currency_exchange_normalization_dict():
+    """Test that a dictionary in currency_exchange is normalized to a list."""
+    test_data = {
+        "transactions": {
+            "booked": [
+                {
+                    "transaction_id": "tx1",
+                    "transaction_amount": {"amount": "-50.00", "currency": "GBP"},
+                    "currency_exchange": {
+                        "source_currency": "GBP",
+                        "exchange_rate": "1.0",
+                    },
+                }
+            ],
+            "pending": [],
+        }
+    }
+
+    # Test AccountTransactions
+    model = AccountTransactions(**test_data)
+    booked_tx = model.transactions["booked"][0]
+    assert isinstance(booked_tx.currency_exchange, list)
+    assert len(booked_tx.currency_exchange) == 1
+    assert booked_tx.currency_exchange[0].source_currency == "GBP"
+
+
+def test_currency_exchange_normalization_with_aliases():
+    """Test normalization using camelCase aliases (user provided example)."""
+    test_data = {
+        "transactions": {
+            "booked": [
+                {
+                    "transactionId": "tx1",
+                    "transactionAmount": {"amount": "-50.00", "currency": "GBP"},
+                    "currencyExchange": {
+                        "sourceCurrency": "GBP",
+                        "exchangeRate": "1.0",
+                    },
+                }
+            ],
+            "pending": [],
+        }
+    }
+
+    model = AccountTransactions(**test_data)
+    booked_tx = model.transactions["booked"][0]
+    assert isinstance(booked_tx.currency_exchange, list)
+    assert len(booked_tx.currency_exchange) == 1
+    assert booked_tx.currency_exchange[0].source_currency == "GBP"
+
+
+def test_currency_exchange_none():
+    """Test that None in currency_exchange remains None."""
+    test_data = {
+        "transaction_id": "tx1",
+        "transaction_amount": {"amount": "-50.00", "currency": "GBP"},
+        "currency_exchange": None,
+    }
+
+    model = BankTransaction(**test_data)
+    assert model.currency_exchange is None
+
+
+def test_currency_exchange_list():
+    """Test that a list in currency_exchange remains a list."""
+    test_data = {
+        "transaction_id": "tx1",
+        "transaction_amount": {"amount": "-50.00", "currency": "GBP"},
+        "currency_exchange": [{"source_currency": "GBP", "exchange_rate": "1.0"}],
+    }
+
+    model = BankTransaction(**test_data)
+    assert isinstance(model.currency_exchange, list)
+    assert len(model.currency_exchange) == 1
+    assert model.currency_exchange[0].source_currency == "GBP"
+
+
+def test_transaction_schema_normalization():
+    """Test normalization in TransactionSchema."""
+    test_data = {
+        "transaction_id": "tx1",
+        "transaction_amount": {"amount": "-50.00", "currency": "GBP"},
+        "currency_exchange": {"source_currency": "GBP", "exchange_rate": "1.0"},
+    }
+
+    model = TransactionSchema(**test_data)
+    assert isinstance(model.currency_exchange, list)
+    assert len(model.currency_exchange) == 1
+
+
+def test_complex_multi_currency_normalization():
+    """Test normalization with the user's complex multi-currency JSON sample."""
+    test_data = {
+        "transactions": {
+            "booked": [
+                {
+                    "transactionId": "uuid",
+                    "bookingDate": "2026-01-05",
+                    "valueDate": "2026-01-06",
+                    "bookingDateTime": "2026-01-05T12:12:09.133455Z",
+                    "valueDateTime": "2026-01-06T02:47:00.1234324Z",
+                    "transactionAmount": {"amount": "-4.07", "currency": "EUR"},
+                    "currencyExchange": {
+                        "instructedAmount": {"amount": "4.07", "currency": "EUR"},
+                        "sourceCurrency": "EUR",
+                        "exchangeRate": "1.15",
+                        "unitCurrency": "EUR",
+                        "targetCurrency": "USD",
+                    },
+                    "creditorName": "Dunkin Donuts",
+                    "remittanceInformationUnstructuredArray": ["Dunkin Donuts"],
+                    "proprietaryBankTransactionCode": "CARD_PAYMENT",
+                    "balanceAfterTransaction": {
+                        "balanceAmount": {"amount": "9.52", "currency": "EUR"},
+                        "balanceType": "InterimBooked",
+                    },
+                    "additionalDataStructured": {
+                        "cardInstrument": {
+                            "cardSchemeName": "MASTERCARD",
+                            "name": "John Doe",
+                            "identification": "1234",
+                        }
+                    },
+                    "internalTransactionId": "85ecaab0e28caccd799bb8b331285ba5",
+                }
+            ],
+            "pending": [],
+        }
+    }
+
+    # This should not raise ValidationError
+    model = AccountTransactions(**test_data)
+    booked_tx = model.transactions["booked"][0]
+
+    assert isinstance(booked_tx.currency_exchange, list)
+    assert len(booked_tx.currency_exchange) == 1
+    assert booked_tx.currency_exchange[0].source_currency == "EUR"
+    assert booked_tx.currency_exchange[0].instructed_amount.amount == "4.07"
+    assert booked_tx.currency_exchange[0].target_currency == "USD"

{beancount_gocardless-0.1.11 → beancount_gocardless-0.1.13}/tests/test_tui.py

@@ -4,8 +4,8 @@ from beancount_gocardless.tui import (
     GoCardLessApp,
     MenuView,
     AccountsView,
-    BalanceView,
-    LinkView,
+    # BalanceView,
+    # LinkView,
     DeleteLinkView,
 )
 from beancount_gocardless.client import GoCardlessClient
@@ -67,16 +67,16 @@ def test_accounts_view_load(mock_client):
     view.accounts_table.update.assert_called()
 
 
-def test_balance_view(mock_client):
-    view = BalanceView(mock_client)
-    content = list(view.compose_content())
-    assert len(content) == 4  # label, static, vertical, button
+# def test_balance_view(mock_client):
+#     view = BalanceView(mock_client)
+#     content = list(view.compose_content())
+#     assert len(content) == 4  # label, static, vertical, button
 
 
-def test_link_view(mock_client):
-    view = LinkView(mock_client)
-    content = list(view.compose_content())
-    assert len(content) == 3  # label, vertical, button
+# def test_link_view(mock_client):
+#     view = LinkView(mock_client)
+#     content = list(view.compose_content())
+#     assert len(content) == 3  # label, vertical, button
 
 
 def test_delete_link_view(mock_client):