Comprehensive comparison for API Integration technology in Software Development applications

import requests
import os
import time
from datetime import datetime, timedelta
from typing import Dict, List, Optional

class NordigenClient:
    """
    Production-ready Nordigen API client for bank account aggregation.
    Handles authentication, account linking, and transaction retrieval.
    """
    
    BASE_URL = "https://ob.nordigen.com/api/v2"
    
    def __init__(self, secret_id: str, secret_key: str):
        self.secret_id = secret_id
        self.secret_key = secret_key
        self.access_token = None
        self.refresh_token = None
        self.token_expiry = None
    
    def authenticate(self) -> bool:
        """Obtain JWT tokens for API access."""
        try:
            response = requests.post(
                f"{self.BASE_URL}/token/new/",
                json={"secret_id": self.secret_id, "secret_key": self.secret_key},
                headers={"Content-Type": "application/json"},
                timeout=10
            )
            response.raise_for_status()
            data = response.json()
            self.access_token = data["access"]
            self.refresh_token = data["refresh"]
            self.token_expiry = datetime.now() + timedelta(seconds=data.get("access_expires", 86400))
            return True
        except requests.exceptions.RequestException as e:
            print(f"Authentication failed: {e}")
            return False
    
    def _get_headers(self) -> Dict[str, str]:
        """Generate headers with valid access token."""
        if not self.access_token or datetime.now() >= self.token_expiry:
            self.authenticate()
        return {"Authorization": f"Bearer {self.access_token}", "Content-Type": "application/json"}
    
    def create_requisition(self, institution_id: str, redirect_uri: str, reference: str) -> Optional[Dict]:
        """Create a requisition for user to link their bank account."""
        try:
            response = requests.post(
                f"{self.BASE_URL}/requisitions/",
                json={
                    "redirect": redirect_uri,
                    "institution_id": institution_id,
                    "reference": reference,
                    "user_language": "EN"
                },
                headers=self._get_headers(),
                timeout=10
            )
            response.raise_for_status()
            return response.json()
        except requests.exceptions.RequestException as e:
            print(f"Requisition creation failed: {e}")
            return None
    
    def get_account_transactions(self, account_id: str, date_from: Optional[str] = None) -> Optional[List[Dict]]:
        """Retrieve transactions for a specific account."""
        if not date_from:
            date_from = (datetime.now() - timedelta(days=90)).strftime("%Y-%m-%d")
        
        try:
            response = requests.get(
                f"{self.BASE_URL}/accounts/{account_id}/transactions/",
                params={"date_from": date_from},
                headers=self._get_headers(),
                timeout=15
            )
            response.raise_for_status()
            data = response.json()
            return data.get("transactions", {}).get("booked", [])
        except requests.exceptions.RequestException as e:
            print(f"Transaction retrieval failed: {e}")
            return None

# Example usage in a Flask API endpoint
if __name__ == "__main__":
    # Initialize client with credentials from environment
    client = NordigenClient(
        secret_id=os.getenv("NORDIGEN_SECRET_ID"),
        secret_key=os.getenv("NORDIGEN_SECRET_KEY")
    )
    
    # Create requisition for UK Revolut
    requisition = client.create_requisition(
        institution_id="REVOLUT_REVOGB21",
        redirect_uri="https://yourapp.com/callback",
        reference=f"user_12345_{int(time.time())}"
    )
    
    if requisition:
        print(f"Requisition link: {requisition['link']}")
        print(f"Requisition ID: {requisition['id']}")
    
    # Retrieve transactions (after user completes linking)
    account_id = "example-account-id-from-requisition"
    transactions = client.get_account_transactions(account_id)
    
    if transactions:
        print(f"Retrieved {len(transactions)} transactions")
        for txn in transactions[:5]:
            print(f"Amount: {txn.get('transactionAmount', {}).get('amount')} - {txn.get('remittanceInformationUnstructured', 'N/A')}")