drf-to-mkdoc 0.1.5__py3-none-any.whl → 0.1.8__py3-none-any.whl

drf_to_mkdoc/static/drf-to-mkdoc/stylesheets/models/responsive.css

@@ -0,0 +1,51 @@
+/* ===== RESPONSIVE DESIGN FOR MODELS ===== */
+
+/* Responsive design improvements */
+@media screen and (max-width: 768px) {
+    .field-grid, .method-grid {
+        grid-template-columns: 1fr;
+    }
+
+    .endpoint-header {
+        flex-direction: column;
+        align-items: flex-start;
+    }
+
+    .endpoint-path {
+        margin-left: 0;
+        margin-top: 0.5rem;
+    }
+}
+
+/* Responsive adjustments for model cards */
+@media screen and (max-width: 768px) {
+    .model-cards {
+        grid-template-columns: 1fr;
+        gap: 1rem;
+    }
+
+    .model-card {
+        padding: 1rem;
+    }
+
+    .model-header h3 {
+        font-size: 1.1rem;
+    }
+
+    .model-badge {
+        font-size: 0.7rem;
+        padding: 0.2rem 0.6rem;
+    }
+}
+
+@media screen and (max-width: 480px) {
+    .model-header {
+        flex-direction: column;
+        align-items: flex-start;
+        gap: 0.5rem;
+    }
+
+    .model-badge {
+        align-self: flex-start;
+    }
+}

drf_to_mkdoc/static/drf-to-mkdoc/stylesheets/models/variables.css

@@ -0,0 +1,46 @@
+/* ===== CSS VARIABLES FOR MODELS ===== */
+:root {
+    /* Colors */
+    --bg-primary: #ffffff;
+    --bg-secondary: #f8fafc;
+    --bg-tertiary: #f1f5f9;
+    
+    --text-primary: #0f172a;
+    --text-secondary: #475569;
+    --text-muted: #64748b;
+    
+    --border-color: #e2e8f0;
+    --border-hover: #cbd5e1;
+    
+    --accent-primary: #3b82f6;
+    --accent-secondary: #1d4ed8;
+    --accent-hover: #2563eb;
+    
+    /* Shadows */
+    --shadow: 0 1px 3px rgba(0, 0, 0, 0.1);
+    --shadow-hover: 0 4px 6px rgba(0, 0, 0, 0.1);
+    --shadow-lg: 0 10px 15px rgba(0, 0, 0, 0.1);
+    
+    /* Transitions */
+    --transition-fast: 0.15s ease;
+    --transition-normal: 0.3s ease;
+    --transition-slow: 0.5s ease;
+}
+
+/* Dark mode */
+[data-md-color-scheme="slate"] {
+    --bg-primary: #1a1a1a;
+    --bg-secondary: #2d2d2d;
+    --bg-tertiary: #404040;
+    
+    --text-primary: #ffffff;
+    --text-secondary: #e5e5e5;
+    --text-muted: #cccccc;
+    
+    --border-color: #404040;
+    --border-hover: #555555;
+    
+    --accent-primary: #60a5fa;
+    --accent-secondary: #3b82f6;
+    --accent-hover: #93c5fd;
+}

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,19 +170,20 @@ 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 DRF_TO_MKDOC_PATH_PARAM_SUBSTITUTOR is set, use that function instead.
+    If PATH_PARAM_SUBSTITUTOR is set, use that function instead.
     """
     function = None
-    func_path = getattr(drf_to_mkdoc_settings, "DRF_TO_MKDOC_PATH_PARAM_SUBSTITUTOR", None)
+    func_path = getattr(drf_to_mkdoc_settings, "PATH_PARAM_SUBSTITUTOR", None)
 
     if func_path:
         try:
             function = import_string(func_path)
         except ImportError:
-            logger.warning("DRF_TO_MKDOC_PATH_PARAM_SUBSTITUTOR is not a valid import path")
+            logger.warning("PATH_PARAM_SUBSTITUTOR is not a valid import path")
 
     # If custom function exists and returns a valid value, use it
     if callable(function):
@@ -193,25 +197,21 @@ def convert_to_django_path(path: str, parameters: list[dict[str, Any]]) -> str:
     # 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'
+        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'
+            converter = "str"
 
-        return f'<{converter}:{param_name}>'
+        return f"<{converter}:{param_name}>"
 
-    django_path = re.sub(r'{(\w+)}', replacement, path)
+    return re.sub(r"{(\w+)}", replacement, path)
 
-    if not django_path.endswith('/'):
-        django_path += '/'
-
-    return django_path
 
 @lru_cache
 def get_schema():
@@ -276,8 +276,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 +291,10 @@ def extract_viewset_from_operation_id(operation_id: str):
         else:
             return view_func
 
-    except Exception as e:
-        raise RuntimeError(f"Failed to resolve path {django_path}: {e}") from e
+    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):