Update to use new model generator with type hints

Author: unigrated-solutions

requirements.txt

@@ -16,4 +16,4 @@ tzdata
 urllib3
 aiohttp
 pyyaml
-clio-api-model-generator==0.2.1
+clio-api-model-generator==0.2.2

setup.py

@@ -10,7 +10,7 @@
 
 setup(
     name="clio-manage-api-client",
-    version="0.1.3",
+    version="0.1.4",
     author="Unigrated Partners",
     author_email="dev@unigratedpartners.com",
     description="Python Client for the Clio Manage API.",

src/clio_manage_python_client/classes/base.py

@@ -2,11 +2,21 @@
 from typing import Dict, Any, Optional, Type, List, Union, Tuple, get_origin, get_args, Literal
 from datetime import datetime
 import typing_inspect
+import logging
+
 from dataclasses import fields, is_dataclass
 
 from ..configs import *
 from ..utils.validate_fields import validate_field_string, build_id_field_string
 
+if not logging.getLogger().hasHandlers():
+    logging.basicConfig(
+        level=logging.INFO,  # default level
+        format="%(asctime)s [%(levelname)s] %(name)s: %(message)s",
+    )
+
+logger = logging.getLogger(__name__)
+
 def is_optional_type(field_type):
     """
     Check if a given type is Optional.
@@ -20,10 +30,12 @@ class BaseRequest:
     def __init__(self, base_url: str, base_path=""):
         self.base_url = base_url
         self.base_path = base_path
+        self.logger = logging.getLogger(self.__class__.__name__)
 
     def format_url(self, path: str, query_params: Dict[str, Any] = None) -> str:
         return f"{self.base_url}{path}"
-
+    
+    @staticmethod
     def convert_array_field(field_name: str, value: Any, item_type: Type) -> Any:
         """
         Convert and validate array query parameters based on API requirements.
@@ -33,6 +45,7 @@ def convert_array_field(field_name: str, value: Any, item_type: Type) -> Any:
         :param item_type: The expected type of the array elements.
         :return: A validated and converted value based on array size and field name.
         """
+        logger = logging.getLogger("BaseRequest.convert_array_field")
         try:
             # Ensure the value is treated as a list
             if not isinstance(value, list):
@@ -74,7 +87,10 @@ def convert_array_field(field_name: str, value: Any, item_type: Type) -> Any:
 
             # Default behavior for fields without double underscores
             return converted_array
+        
         except (ValueError, TypeError) as e:
+            
+            logger.error("Invalid value for array field '%s': %s", field_name, e)
             return {"error": f"Invalid value for array field '{field_name}': {e}"}
 
     def validate_and_convert(self, field_name: str, field_type: Type, value: Any, required: bool) -> Any:
@@ -88,6 +104,8 @@ def validate_and_convert(self, field_name: str, field_type: Type, value: Any, re
 
         # Skip validation for optional fields with None value
         if not required and value is None:
+            print("Required field '%s' not provided", field_name)
+            self.logger.error("Required field '%s' not provided", field_name)
             return None
 
         if value is not None:
@@ -195,7 +213,9 @@ def validate_and_convert(self, field_name: str, field_type: Type, value: Any, re
                     return bool(value)
                 elif field_type == str:
                     return str(value)
-            except (ValueError, TypeError):
+                
+            except (ValueError, TypeError) as e:
+                self.logger.error("Validation error for field '%s': %s", field_name, e)
                 return {"error": f"Invalid value for field '{field_name}': Expected {field_type}, got {type(value).__name__}."}
 
         return None
@@ -214,7 +234,7 @@ def process_model(model: Type, data: Dict[str, Any]) -> Tuple[Dict[str, Any], Di
             errors = {}
 
             for field_name, field_type in model.__annotations__.items():
-                print(field_name, field_type)
+                # print(field_name, field_type)
                 # Use the provided field name for validation; apply mappings after validation
                 original_field_name = field_name
                 mapped_field_name = MAPPINGS.get(field_name, field_name)
@@ -227,7 +247,11 @@ def process_model(model: Type, data: Dict[str, Any]) -> Tuple[Dict[str, Any], Di
 
                 if value is None:
                     if not is_optional:
-                        errors[original_field_name] = f"'{original_field_name}' is required but not provided."
+                        msg = f"'{original_field_name}' is required but not provided."
+                        self.logger.error(msg)
+                        errors[original_field_name] = msg
+                        # raise ValueError(msg)
+                    
                     continue
 
                 # Process nested models

src/clio_manage_python_client/client.py

@@ -9,6 +9,27 @@
 from .utils import RateMonitor
 
 class Client:
+    if TYPE_CHECKING:
+        get: "GetRequest"
+        post: "PostRequest"
+        create: "PostRequest"
+        update: "PatchRequest"
+        patch: "PatchRequest"
+        delete: "DeleteRequest"
+        download: "DownloadRequest"
+        all: "AllRequests"
+
+    request_methods = {
+        "get": Get,
+        "post": Post,
+        "create": Post,
+        "patch": Patch,
+        "delete": Delete,
+        "download": Download,
+        "all": All,  # For auto paginating record retrieval 
+        "put": Put # Unused
+    }
+        
     def __init__(self,
                  access_token: str,
                  region: str = "US",
@@ -44,22 +65,9 @@ def __init__(self,
         # Initialize RateMonitor with optional default_limit
         self.rate_limiter = RateMonitor(**({"default_limit": default_rate_limit} if default_rate_limit is not None else {}))
 
-        # List of HTTP methods and their corresponding handler classes
-        self.request_methods = REQUEST_METHODS
-        
-        request_handler_classes = {
-            "get": Get,
-            "post": Post,
-            "patch": Patch,
-            "delete": Delete,
-            "download": Download,
-            "all": All,  # For auto paginating record retrieval 
-            "put": Put # Unused
-        }
-
         # Dynamically initialize and set request handlers as attributes
-        for method in self.request_methods:
-            handler_class = request_handler_classes[method]
+        for method in self.request_methods.keys():
+            handler_class = self.request_methods[method]
             setattr(self, method, handler_class(self.base_url, self.request_handler))
 
     def __getattr__(self, item: str):
@@ -72,10 +80,11 @@ def __getattr__(self, item: str):
                 return getattr(handler, item)
         raise AttributeError(f"'Client' object has no attribute '{item}'")
 
-    # Syncronous Requests
+    # Synchronous Requests
     def _make_request(self, api_url: str, method: str, params: dict = None, payload: dict = None, return_all=False):
         """
         Makes the actual HTTP request based on the method.
+        Handles empty or non-JSON responses safely.
         """
         headers = {
             "Authorization": f"Bearer {self.access_token}",
@@ -93,18 +102,32 @@ def _make_request(self, api_url: str, method: str, params: dict = None, payload:
                 json=payload,
             )
             response.raise_for_status()
-            return response.json(), response
-        
+
+            # Safely handle JSON or empty responses
+            if response.content:
+                try:
+                    data = response.json()
+                except ValueError:
+                    # Response is not JSON
+                    data = response.text
+            else:
+                data = None  # No content
+
+            return data, response
+
         except requests.exceptions.RequestException as e:
-            raise RuntimeError(f"HTTP request failed: {e}") from e
+            # Provide more info including raw response text if available
+            resp_text = getattr(e.response, "text", "") if hasattr(e, "response") else ""
+            raise RuntimeError(f"HTTP request failed: {e}. Response body: {resp_text}") from e
+
 
     def _request_handler(self, api_url: str, method: str, params: dict = None, payload: dict = None, return_all=False, **kwargs):
         """
         Handles requests, including support for paginated responses when return_all=True.
         """
         endpoint = api_url.split(self.base_url)[-1].split("?")[0]  # Extract endpoint from URL
         params = params or {}
-        # print(f'Return ALl: {return_all}')
+
         @self.rate_limiter(endpoint)
         def make_request():
             try:

src/clio_manage_python_client/configs.py

@@ -1,7 +1,15 @@
 from pathlib import Path
+from typing import TYPE_CHECKING
 
-DEFAULT_MODEL_DIRECTORY = Path(__file__).resolve().parent / "models"
-REQUEST_METHODS = ["get", "put", "post", "patch", "delete", "download", "all"]
+if TYPE_CHECKING:
+    from .models.method_hints import (
+        Get as GetRequest,
+        Post as PostRequest,
+        Patch as PatchRequest,
+        Delete as DeleteRequest,
+        Download as DownloadRequest,
+        All as AllRequests
+    )
 
 MAPPINGS = {
             "X_API_VERSION": "X-API-VERSION",
@@ -24,4 +32,4 @@
     "eu": "https://eu.app.clio.com"
 }
 
-API_VERSION_PATH = {4: "api/v4"}
+API_VERSION_PATH = {4: "api/v4"}