refactor: simplify models and update SDK documentation; remove obsolete model files and enhance client initialization

Author: princemuichkine

lomi/__init__.py

@@ -1,10 +1,6 @@
-"""
-lomi. Python SDK
-AUTO-GENERATED - Do not edit manually
-"""
+"""lomi Python SDK — public merchant API surface."""
 
 from .client import LomiClient
 from .exceptions import LomiError, LomiAuthError, LomiNotFoundError
-from .models import *
 
-__version__ = "1.0.0"
+__all__ = ["LomiClient", "LomiError", "LomiAuthError", "LomiNotFoundError"]

lomi/client.py

@@ -1,91 +1,96 @@
-"""
-lomi. Python SDK Client
-AUTO-GENERATED - Do not edit manually
-"""
+"""lomi. Python SDK — generated from OpenAPI + public allowlist."""
 
 import requests
-from typing import Optional, Dict, Any, List, Type, TypeVar
+from typing import Optional, Dict, Any
+
 from .exceptions import LomiError, LomiAuthError, LomiNotFoundError
-from .models import *
 from .services import *
-from pydantic import BaseModel
 
-T = TypeVar("T", bound=BaseModel)
+def _flatten_data(data):
+    if data is None:
+        return None
+    if hasattr(data, "model_dump"):
+        return data.model_dump(exclude_unset=True)
+    if hasattr(data, "dict"):
+        return data.dict(exclude_unset=True)
+    return data
+
 
 class LomiClient:
-    """Main lomi. SDK client"""
-    
+    """Merchant API client (public routes only)."""
+
     def __init__(
         self,
         api_key: str,
         base_url: str = "https://api.lomi.africa",
-        environment: str = "live"
+        environment: str = "live",
     ):
         self.api_key = api_key
-        self.base_url = base_url if environment != "test" else "https://sandbox.api.lomi.africa"
+        test_host = environment in ("test", "sandbox") or (
+            isinstance(environment, str) and environment.lower() == "test"
+        )
+        self.base_url = (
+            base_url if not test_host else "https://sandbox.api.lomi.africa"
+        )
         self.session = requests.Session()
-        self.session.headers.update({
-            "X-API-KEY": api_key,
-            "Content-Type": "application/json",
-        })
-        
-        # Initialize service instances
+        self.session.headers.update(
+            {"X-API-KEY": api_key, "Content-Type": "application/json"}
+        )
         self.accounts = AccountsService(self)
-        self.organizations = OrganizationsService(self)
+        self.beneficiary_payouts = BeneficiaryPayoutsService(self)
+        self.charges = ChargesService(self)
+        self.checkout_sessions = CheckoutSessionsService(self)
         self.customers = CustomersService(self)
-        self.payment_requests = PaymentRequestsService(self)
-        self.transactions = TransactionsService(self)
-        self.refunds = RefundsService(self)
-        self.products = ProductsService(self)
-        self.subscriptions = SubscriptionsService(self)
         self.discount_coupons = DiscountCouponsService(self)
-        self.checkout_sessions = CheckoutSessionsService(self)
+        self.organizations = OrganizationsService(self)
+        self.payment_intents = PaymentIntentsService(self)
         self.payment_links = PaymentLinksService(self)
+        self.payment_requests = PaymentRequestsService(self)
         self.payouts = PayoutsService(self)
-        self.beneficiary_payouts = BeneficiaryPayoutsService(self)
-        self.webhooks = WebhooksService(self)
+        self.products = ProductsService(self)
+        self.refunds = RefundsService(self)
+        self.subscriptions = SubscriptionsService(self)
+        self.transactions = TransactionsService(self)
         self.webhook_delivery_logs = WebhookDeliveryLogsService(self)
-    
+        self.webhooks = WebhooksService(self)
+
     def _request(
         self,
         method: str,
         path: str,
-        model: Type[T] = None,
         params: Optional[Dict[str, Any]] = None,
         data: Optional[Dict[str, Any]] = None,
     ) -> Any:
-        """Make an HTTP request to the API"""
         url = f"{self.base_url}{path}"
-        
-        # Convert Pydantic models to dict if passed as data
-        json_data = data
-        if hasattr(data, 'dict'):
-             json_data = data.dict(exclude_unset=True)
-
+        json_data = _flatten_data(data)
         try:
             response = self.session.request(
                 method=method,
                 url=url,
                 params=params,
                 json=json_data,
             )
-            
+
             if response.status_code == 401:
-                raise LomiAuthError("Invalid API key", response.status_code, response.json())
-            elif response.status_code == 404:
-                raise LomiNotFoundError("Resource not found", response.status_code, response.json())
-            elif response.status_code >= 400:
-                raise LomiError(f"API error: {response.text}", response.status_code, response.json() if response.text else None)
-            
-            resp_data = response.json() if response.text else None
-            
-            # If model class provided, parse response
-            if model and resp_data:
-                if isinstance(resp_data, list):
-                    return [model(**item) for item in resp_data]
-                return model(**resp_data)
-                
-            return resp_data
-            
+                raise LomiAuthError(
+                    "Invalid API key",
+                    response.status_code,
+                    response.json() if response.content else None,
+                )
+            if response.status_code == 404:
+                raise LomiNotFoundError(
+                    "Resource not found",
+                    response.status_code,
+                    response.json() if response.content else None,
+                )
+            if response.status_code >= 400:
+                raise LomiError(
+                    f"API error: {response.text}",
+                    response.status_code,
+                    response.json() if response.text else None,
+                )
+
+            return response.json() if response.content else None
         except requests.RequestException as e:
-            raise LomiError(f"Request failed: {str(e)}")
+            raise LomiError(f"Request failed: {type(e).__name__}: {e}") from e
+

lomi/client_base.py

@@ -1,17 +1,26 @@
 
-from typing import Optional, Dict, Any, List, Type, TypeVar, TYPE_CHECKING
+from typing import Optional, Dict, Any, TYPE_CHECKING
+import warnings
 import requests
+
 from .exceptions import LomiError, LomiAuthError, LomiNotFoundError
-from pydantic import BaseModel
 
 if TYPE_CHECKING:
     from .client import LomiClient
 
-T = TypeVar("T", bound=BaseModel)
 
 class ClientBase:
-    def __init__(self, client: 'LomiClient'):
+    """HTTP helpers shared by generated services."""
+
+    def __init__(self, client: "LomiClient"):
         self._client = client
 
-    def _request(self, method: str, path: str, model: Type[T] = None, params: Optional[Dict[str, Any]] = None, data: Optional[Dict[str, Any]] = None) -> Any:
-        return self._client._request(method, path, model, params, data)
+    def _request(
+        self,
+        method: str,
+        path: str,
+        params: Optional[Dict[str, Any]] = None,
+        data: Optional[Dict[str, Any]] = None,
+    ) -> Any:
+        """Make an HTTP request to the merchant API."""
+        return self._client._request(method, path, params=params, data=data)

lomi/exceptions.py

@@ -1,19 +1,20 @@
-"""
-lomi. SDK Exceptions
-AUTO-GENERATED - Do not edit manually
-"""
+"""lomi-sdk exceptions."""
+
+from typing import Optional, Any
+
 
 class LomiError(Exception):
-    """Base exception for lomi. SDK"""
-    def __init__(self, message: str, status_code: int = None, body: dict = None):
+    """Base SDK error."""
+
+    def __init__(self, message: str, status_code: Optional[int] = None, body: Any = None):
         super().__init__(message)
         self.status_code = status_code
         self.body = body
 
+
 class LomiAuthError(LomiError):
-    """Authentication error"""
-    pass
+    """Invalid API credentials."""
+
 
 class LomiNotFoundError(LomiError):
-    """Resource not found error"""
-    pass
+    """Resource missing."""

lomi/models/__init__.py

@@ -1,20 +1,5 @@
-"""
-lomi. Models
-"""
-from typing import *
+"""Types are dictated by the public API OpenAPI schema; use Dict[str, Any] or narrow in your app."""
+from typing import Any, Dict
 
-from .accounts import Accounts, AccountsCreate, AccountsUpdate
-from .organizations import Organizations, OrganizationsCreate, OrganizationsUpdate
-from .customers import Customers, CustomersCreate, CustomersUpdate
-from .payment_requests import PaymentRequests, PaymentRequestsCreate, PaymentRequestsUpdate
-from .transactions import Transactions, TransactionsCreate, TransactionsUpdate
-from .refunds import Refunds, RefundsCreate, RefundsUpdate
-from .products import Products, ProductsCreate, ProductsUpdate
-from .subscriptions import Subscriptions, SubscriptionsCreate, SubscriptionsUpdate
-from .discount_coupons import DiscountCoupons, DiscountCouponsCreate, DiscountCouponsUpdate
-from .checkout_sessions import CheckoutSessions, CheckoutSessionsCreate, CheckoutSessionsUpdate
-from .payment_links import PaymentLinks, PaymentLinksCreate, PaymentLinksUpdate
-from .payouts import Payouts, PayoutsCreate, PayoutsUpdate
-from .beneficiary_payouts import BeneficiaryPayouts, BeneficiaryPayoutsCreate, BeneficiaryPayoutsUpdate
-from .webhooks import Webhooks, WebhooksCreate, WebhooksUpdate
-from .webhook_delivery_logs import WebhookDeliveryLogs, WebhookDeliveryLogsCreate, WebhookDeliveryLogsUpdate
+__all__ = ["JSONDict"]
+JSONDict = Dict[str, Any]