.md

services

│
├── services/
│   ├── __init__.py
│   ├── base_service.py   # Base class for shared logic (e.g., authentication, headers)
│   ├── cards_service.py  # Service-specific logic for "cards"
│   ├── my_info_service.py  # Service-specific logic for "my-info"
│   ├── documents_service.py  # Service-specific logic for "documents"
│
├── models/
│   ├── __init__.py
│   ├── base_model.py  # Shared Pydantic models (e.g., common fields or base response structure)
│   ├── cards_models.py  # Pydantic models for "cards"
│   ├── my_info_models.py  # Pydantic models for "my-info"
│   ├── documents_models.py  # Pydantic models for "documents"
│
├── config.py  # Configuration (e.g., service URLs, secrets)
├── utils.py   # Utility functions (e.g., token generation, logging)
└── main.py    # Application entry point or orchestrator

config.py

from pydantic import BaseSettings

class Settings(BaseSettings):
    jwt_secret: str
    cards_base_url: str
    my_info_base_url: str
    documents_base_url: str

    class Config:
        env_file = ".env"

settings = Settings()

base_service.py

import requests

class BaseService:
    def __init__(self, base_url: str, jwt_token: str):
        self.base_url = base_url
        self.headers = {
            "Authorization": f"Bearer {jwt_token}",
            "Content-Type": "application/json",
        }

    def get(self, endpoint: str, params: dict = None):
        response = requests.get(f"{self.base_url}/{endpoint}", headers=self.headers, params=params)
        response.raise_for_status()
        return response.json()

    def post(self, endpoint: str, data: dict):
        response = requests.post(f"{self.base_url}/{endpoint}", headers=self.headers, json=data)
        response.raise_for_status()
        return response.json()

cards_service.py

from .base_service import BaseService
from ..models.cards_models import CardRequest, CardResponse

class CardsService(BaseService):
    def get_card_details(self, card_id: str) -> CardResponse:
        response_data = self.get(f"cards/{card_id}")
        return CardResponse(**response_data)

    def create_card(self, card_data: CardRequest) -> CardResponse:
        response_data = self.post("cards", card_data.dict())
        return CardResponse(**response_data)

cards_models.py

from pydantic import BaseModel
from typing import List

class CardRequest(BaseModel):
    card_type: str
    user_id: str

class CardResponse(BaseModel):
    card_id: str
    card_type: str
    status: str
    allowed_users: List[str]

main.py

from services.cards_service import CardsService
from config import settings

def main():
    # Example token generation (replace with actual logic)
    jwt_token = "example_jwt_token"

    # Initialize services
    cards_service = CardsService(base_url=settings.cards_base_url, jwt_token=jwt_token)

    # Call a service
    card_request = {"card_type": "debit", "user_id": "12345"}
    response = cards_service.create_card(card_request)
    print(response)

if __name__ == "__main__":
    main()