drf-to-mkdoc 0.1.6__py3-none-any.whl → 0.1.9__py3-none-any.whl

drf_to_mkdoc/utils/common.py

@@ -1,19 +1,21 @@
-from asyncio.log import logger
 import importlib
-import yaml
 import json
 import re
+from asyncio.log import logger
 from functools import lru_cache
 from pathlib import Path
-from typing import Any, Optional
+from typing import Any
 
+import yaml
 from django.apps import apps
 from django.core.exceptions import AppRegistryNotReady
 from django.urls import resolve
 from django.utils.module_loading import import_string
 from drf_spectacular.generators import SchemaGenerator
+
 from drf_to_mkdoc.conf.settings import drf_to_mkdoc_settings
 
+
 class SchemaValidationError(Exception):
     """Custom exception for schema validation errors."""
 
@@ -37,9 +39,10 @@ def substitute_path_params(path: str, parameters: list[dict[str, Any]]) -> str:
     django_path = re.sub(r"<path:[^>]+>", "dummy/path", django_path)
     django_path = re.sub(r"<[^:>]+>", "dummy", django_path)  # Catch remaining simple params
 
-    return django_path
+    return django_path  # noqa: RET504
 
-def load_schema() -> Optional[dict[str, Any]]:
+
+def load_schema() -> dict[str, Any] | None:
     """Load the OpenAPI schema from doc-schema.yaml"""
     schema_file = Path(drf_to_mkdoc_settings.CONFIG_DIR) / "doc-schema.yaml"
     if not schema_file.exists():
@@ -49,7 +52,7 @@ def load_schema() -> Optional[dict[str, Any]]:
         return yaml.safe_load(f)
 
 
-def load_model_json_data() -> Optional[dict[str, Any]]:
+def load_model_json_data() -> dict[str, Any] | None:
     """Load the JSON mapping data for model information"""
     json_file = Path(drf_to_mkdoc_settings.MODEL_DOCS_FILE)
     if not json_file.exists():
@@ -59,7 +62,7 @@ def load_model_json_data() -> Optional[dict[str, Any]]:
         return json.load(f)
 
 
-def load_doc_config() -> Optional[dict[str, Any]]:
+def load_doc_config() -> dict[str, Any] | None:
     """Load the documentation configuration file"""
     config_file = Path(drf_to_mkdoc_settings.DOC_CONFIG_FILE)
     if not config_file.exists():
@@ -69,7 +72,7 @@ def load_doc_config() -> Optional[dict[str, Any]]:
         return json.load(f)
 
 
-def get_model_docstring(class_name: str) -> Optional[str]:
+def get_model_docstring(class_name: str) -> str | None:
     """Extract docstring from Django model class"""
     try:
         # Check if Django is properly initialized
@@ -167,51 +170,53 @@ def get_custom_schema():
                     raise QueryParamTypeError("Invalid queryparam_type")
     return data
 
+
 def convert_to_django_path(path: str, parameters: list[dict[str, Any]]) -> str:
     """
     Convert a path with {param} to a Django-style path with <type:param>.
-    If PATH_PARAM_SUBSTITUTOR is set, use that function instead.
+    If PATH_PARAM_SUBSTITUTE_FUNCTION is set, use that function instead.
     """
     function = None
-    func_path = getattr(drf_to_mkdoc_settings, "PATH_PARAM_SUBSTITUTOR", None)
+    func_path = drf_to_mkdoc_settings.PATH_PARAM_SUBSTITUTE_FUNCTION
 
     if func_path:
         try:
             function = import_string(func_path)
         except ImportError:
-            logger.warning("PATH_PARAM_SUBSTITUTOR is not a valid import path")
+            logger.warning("PATH_PARAM_SUBSTITUTE_FUNCTION is not a valid import path")
 
     # If custom function exists and returns a valid value, use it
+    PATH_PARAM_SUBSTITUTE_MAPPING = drf_to_mkdoc_settings.PATH_PARAM_SUBSTITUTE_MAPPING
     if callable(function):
         try:
-            value = function(path, parameters)
-            if isinstance(value, str) and value.strip():
-                return value
+            result = function(path, parameters)
+            if result and isinstance(result, dict):
+                PATH_PARAM_SUBSTITUTE_MAPPING.update(result)
         except Exception as e:
             logger.exception("Error in custom path substitutor: %s", e)
 
     # Default Django path conversion
     def replacement(match):
         param_name = match.group(1)
-        param_info = next((p for p in parameters if p.get('name') == param_name), {})
-        param_type = param_info.get('schema', {}).get('type')
-        param_format = param_info.get('schema', {}).get('format')
-
-        if param_type == 'integer':
-            converter = 'int'
-        elif param_type == 'string' and param_format == 'uuid':
-            converter = 'uuid'
+        custom_param_type = PATH_PARAM_SUBSTITUTE_MAPPING.get(param_name)
+        if custom_param_type and custom_param_type in ("int", "uuid", "str"):
+            converter = custom_param_type
         else:
-            converter = 'str'
-
-        return f'<{converter}:{param_name}>'
+            param_info = next((p for p in parameters if p.get("name") == param_name), {})
+            param_type = param_info.get("schema", {}).get("type")
+            param_format = param_info.get("schema", {}).get("format")
+
+            if param_type == "integer":
+                converter = "int"
+            elif param_type == "string" and param_format == "uuid":
+                converter = "uuid"
+            else:
+                converter = "str"
 
-    django_path = re.sub(r'{(\w+)}', replacement, path)
+        return f"<{converter}:{param_name}>"
 
-    if not django_path.endswith('/'):
-        django_path += '/'
+    return re.sub(r"{(\w+)}", replacement, path)
 
-    return django_path
 
 @lru_cache
 def get_schema():
@@ -276,8 +281,8 @@ def extract_viewset_from_operation_id(operation_id: str):
     if not path:
         raise ValueError(f"Path not found for operation ID: {operation_id}")
 
+    resolved_path = substitute_path_params(path, parameters)
     try:
-        resolved_path = substitute_path_params(path, parameters)
         match = resolve(resolved_path)
         view_func = match.func
         if hasattr(view_func, "view_class"):
@@ -291,8 +296,10 @@ def extract_viewset_from_operation_id(operation_id: str):
         else:
             return view_func
 
-    except Exception as e:
-        logger.error(f"Failed to resolve path {path}")
+    except Exception:
+        logger.error(
+            f"Failed to resolve path.\nschema_path{path}\ntried_path={resolved_path}\n---"
+        )
 
 
 def extract_viewset_name_from_operation_id(operation_id: str):