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

drf_to_mkdoc/__init__.py

@@ -4,4 +4,4 @@ DRF to MkDocs - Generate Markdown API docs from Django/DRF OpenAPI schema for Mk
 
 __version__ = "0.1.0"
 __author__ = "ShayestehHs"
-__email__ = "shayestehhs1@gmail.com"
+__email__ = "shayestehhs1@gmail.com"

drf_to_mkdoc/apps.py

@@ -1,15 +1,19 @@
+import logging
+
 from django.apps import AppConfig
 
+logger = logging.getLogger()
+
 
 class DrfToMkdocConfig(AppConfig):
     default_auto_field = "django.db.models.BigAutoField"
     name = "drf_to_mkdoc"
     verbose_name = "DRF to MkDocs Documentation Generator"
-    
+
     def ready(self):
         """Initialize the app when Django starts."""
         # Import management commands to register them
         try:
             import drf_to_mkdoc.management.commands  # noqa
         except ImportError:
-            pass 
+            logger.exception("Failed to import drf_to_mkdoc commands")

drf_to_mkdoc/conf/defaults.py

@@ -5,7 +5,6 @@ DEFAULTS = {
     "MODEL_DOCS_FILE": "docs/model-docs.json",  # Path to model documentation JSON file
     "DOC_CONFIG_FILE": "docs/configs/doc_config.json",  # Path to documentation configuration file
     "CUSTOM_SCHEMA_FILE": "docs/configs/custom_schema.json",  # Path to custom schema file
-
     # Django apps - required, no default
     "DJANGO_APPS": None,  # List of Django app names to process
 }

drf_to_mkdoc/conf/settings.py

@@ -1,6 +1,8 @@
 from django.conf import settings
+
 from drf_to_mkdoc.conf.defaults import DEFAULTS
 
+
 class DRFToMkDocSettings:
     required_settings = ["DJANGO_APPS"]
 
@@ -12,15 +14,15 @@ class DRFToMkDocSettings:
     def get(self, key):
         if key not in self.defaults:
             raise AttributeError(f"Invalid DRF_TO_MKDOC setting: '{key}'")
-        
+
         value = self._user_settings.get(key, self.defaults[key])
-        
+
         if value is None and key in self.required_settings:
             raise ValueError(
                 f"DRF_TO_MKDOC setting '{key}' is required but not configured. "
                 f"Please add it to your Django settings under {self.user_settings_key}."
             )
-        
+
         return value
 
     def __getattr__(self, key):
@@ -28,17 +30,18 @@ class DRFToMkDocSettings:
 
     def validate_required_settings(self):
         missing_settings = []
-        
+
         for setting in self.required_settings:
             try:
                 self.get(setting)
             except ValueError:
                 missing_settings.append(setting)
-        
+
         if missing_settings:
             raise ValueError(
                 f"Missing required settings: {', '.join(missing_settings)}. "
                 f"Please configure these in your Django settings under {self.user_settings_key}."
             )
 
+
 drf_to_mkdoc_settings = DRFToMkDocSettings(defaults=DEFAULTS)

drf_to_mkdoc/management/commands/build_docs.py

@@ -1,11 +1,12 @@
+import shutil
 import subprocess
 from pathlib import Path
 
-from django.conf import settings
-from django.core.management.base import BaseCommand, CommandError
 from django.apps import apps
-from drf_to_mkdoc.conf.settings import drf_to_mkdoc_settings
+from django.conf import settings
 from django.core.management import call_command
+from django.core.management.base import BaseCommand, CommandError
+from your_app import drf_to_mkdoc_settings  # Replace with your actual import
 
 
 class Command(BaseCommand):
@@ -18,13 +19,13 @@ class Command(BaseCommand):
         try:
             apps.check_apps_ready()
         except Exception as e:
-            raise CommandError(f"Django apps not properly configured: {e}")
+            raise CommandError(f"Django apps not properly configured: {e}") from e
 
         base_dir = Path(settings.BASE_DIR)
         site_dir = base_dir / "site"
         mkdocs_config = base_dir / "mkdocs.yml"
         mkdocs_config_alt = base_dir / "mkdocs.yaml"
-        
+
         if not mkdocs_config.exists() and not mkdocs_config_alt.exists():
             raise CommandError(
                 "MkDocs configuration file not found. Please create either 'mkdocs.yml' or 'mkdocs.yaml' "
@@ -34,10 +35,7 @@ class Command(BaseCommand):
         try:
             # Generate the model documentation JSON first
             self.stdout.write("Generating model documentation...")
-
-            call_command(
-                "generate_model_docs", "--pretty"
-            )
+            call_command("generate_model_docs", "--pretty")
             self.stdout.write(self.style.SUCCESS("Model documentation generated."))
 
             # Generate the documentation content
@@ -47,17 +45,7 @@ class Command(BaseCommand):
 
             # Build the MkDocs site
             self.stdout.write("Building MkDocs site...")
-            result = subprocess.run(
-                ["mkdocs", "build", "--clean"],
-                check=False,
-                cwd=base_dir,
-                capture_output=True,
-                text=True,
-            )
-
-            if result.returncode != 0:
-                raise CommandError(f"MkDocs build failed: {result.stderr}")
-
+            self._build_mkdocs_site(base_dir, site_dir)
             self.stdout.write(self.style.SUCCESS("Documentation built successfully!"))
             self.stdout.write(f"Site built in: {site_dir}")
 
@@ -65,3 +53,56 @@ class Command(BaseCommand):
             raise CommandError(
                 "MkDocs not found. Please install it with: pip install mkdocs mkdocs-material"
             ) from e
+
+    def _build_mkdocs_site(self, base_dir: Path, site_dir: Path) -> None:
+        """
+        Build the MkDocs site with proper security checks.
+
+        Args:
+            base_dir: The base directory of the Django project
+            site_dir: The directory where the site will be built
+
+        Raises:
+            FileNotFoundError: If mkdocs executable is not found
+            CommandError: If the build process fails
+        """
+        mkdocs_path = shutil.which("mkdocs")
+        if not mkdocs_path:
+            raise FileNotFoundError("mkdocs executable not found in PATH")
+
+        mkdocs_path_obj = Path(mkdocs_path)
+        if not mkdocs_path_obj.exists() or not mkdocs_path_obj.is_file():
+            raise CommandError(f"Invalid mkdocs executable path: {mkdocs_path}")
+
+        if not base_dir.is_absolute():
+            base_dir = base_dir.resolve()
+
+        if not base_dir.exists():
+            raise CommandError(f"Base directory does not exist: {base_dir}")
+
+        cmd = [
+            str(mkdocs_path_obj),  # Convert to string for subprocess
+            "build",
+            "--clean",
+        ]
+
+        try:
+            result = subprocess.run(  # noqa S603
+                cmd,
+                check=True,
+                cwd=str(base_dir),
+                capture_output=True,
+                text=True,
+                timeout=300,
+            )
+
+            if result.stdout:
+                self.stdout.write(f"MkDocs output: {result.stdout}")
+
+        except subprocess.TimeoutExpired as e:
+            raise CommandError("MkDocs build timed out after 5 minutes") from e
+        except subprocess.CalledProcessError as e:
+            error_msg = f"MkDocs build failed (exit code {e.returncode})"
+            if e.stderr:
+                error_msg += f": {e.stderr}"
+            raise CommandError(error_msg) from e

drf_to_mkdoc/management/commands/generate_docs.py

@@ -4,6 +4,7 @@ from pathlib import Path
 
 from django.core.management.base import BaseCommand
 
+from drf_to_mkdoc.conf.settings import drf_to_mkdoc_settings
 from drf_to_mkdoc.utils.common import get_schema, load_model_json_data
 from drf_to_mkdoc.utils.endpoint_generator import (
     create_endpoints_index,
@@ -11,8 +12,6 @@ from drf_to_mkdoc.utils.endpoint_generator import (
     parse_endpoints_from_schema,
 )
 from drf_to_mkdoc.utils.model_generator import create_models_index, generate_model_docs
-from drf_to_mkdoc.conf.settings import drf_to_mkdoc_settings
-
 
 
 class Command(BaseCommand):

drf_to_mkdoc/management/commands/generate_model_docs.py

@@ -9,6 +9,7 @@ from django.db import models
 
 from drf_to_mkdoc.conf.settings import drf_to_mkdoc_settings
 
+
 class Command(BaseCommand):
     help = "Generate model documentation JSON from Django model introspection"
 

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,6 +170,7 @@ 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>.
@@ -193,26 +197,27 @@ 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)
+    django_path = re.sub(r"{(\w+)}", replacement, path)
 
-    if not django_path.endswith('/'):
-        django_path += '/'
+    if not django_path.endswith("/"):
+        django_path += "/"
 
     return django_path
 
+
 @lru_cache
 def get_schema():
     base_schema = SchemaGenerator().get_schema(request=None, public=True)
@@ -291,7 +296,7 @@ def extract_viewset_from_operation_id(operation_id: str):
         else:
             return view_func
 
-    except Exception as e:
+    except Exception:
         logger.error(f"Failed to resolve path {path}")
 
 

drf_to_mkdoc/utils/endpoint_generator.py

@@ -1,12 +1,14 @@
-#!/usr/bin/env python3
-
 import ast
 import inspect
 import json
+import logging
 from collections import defaultdict
 from pathlib import Path
 from typing import Any
 
+from django.apps import apps
+from rest_framework import serializers
+
 from drf_to_mkdoc.conf.settings import drf_to_mkdoc_settings
 from drf_to_mkdoc.utils.common import (
     create_safe_filename,
@@ -17,30 +19,35 @@ from drf_to_mkdoc.utils.common import (
     get_custom_schema,
     write_file,
 )
-from drf_to_mkdoc.utils.extractors.query_parameter_extractors import extract_query_parameters_from_view
-from drf_to_mkdoc.utils.md_generators.query_parameters_generators import generate_query_parameters_md
+from drf_to_mkdoc.utils.extractors.query_parameter_extractors import (
+    extract_query_parameters_from_view,
+)
+from drf_to_mkdoc.utils.md_generators.query_parameters_generators import (
+    generate_query_parameters_md,
+)
+
+logger = logging.getLogger()
 
 
 def analyze_serializer_method_field_schema(serializer_class, field_name: str) -> dict:
     """Analyze a SerializerMethodField to determine its actual return type schema."""
     method_name = f"get_{field_name}"
 
-
     # Strategy 2: Check type annotations
     schema_from_annotations = _extract_schema_from_type_hints(serializer_class, method_name)
     if schema_from_annotations:
         return schema_from_annotations
-    
+
     # Strategy 3: Analyze method source code
     schema_from_source = _analyze_method_source_code(serializer_class, method_name)
     if schema_from_source:
         return schema_from_source
-    
+
     # Strategy 4: Runtime analysis (sample execution)
     schema_from_runtime = _analyze_method_runtime(serializer_class, method_name)
     if schema_from_runtime:
         return schema_from_runtime
-    
+
     # Fallback to string
     return {"type": "string"}
 
@@ -51,24 +58,24 @@ def _extract_schema_from_decorator(serializer_class, method_name: str) -> dict:
         method = getattr(serializer_class, method_name, None)
         if not method:
             return None
-            
+
         # Check if method has the decorator attribute (drf-spectacular)
-        if hasattr(method, '_spectacular_annotation'):
+        if hasattr(method, "_spectacular_annotation"):
             annotation = method._spectacular_annotation
             # Handle OpenApiTypes
-            if hasattr(annotation, 'type'):
+            if hasattr(annotation, "type"):
                 return {"type": annotation.type}
-            elif isinstance(annotation, dict):
+            if isinstance(annotation, dict):
                 return annotation
-            
+
         # Check for drf-yasg decorator
-        if hasattr(method, '_swagger_serializer_method'):
+        if hasattr(method, "_swagger_serializer_method"):
             swagger_info = method._swagger_serializer_method
-            if hasattr(swagger_info, 'many') and hasattr(swagger_info, 'child'):
+            if hasattr(swagger_info, "many") and hasattr(swagger_info, "child"):
                 return {"type": "array", "items": {"type": "object"}}
-            
+
     except Exception:
-        pass
+        logger.exception("Failed to extract schema from decorator")
     return None
 
 
@@ -78,30 +85,30 @@ def _extract_schema_from_type_hints(serializer_class, method_name: str) -> dict:
         method = getattr(serializer_class, method_name, None)
         if not method:
             return None
-            
+
         signature = inspect.signature(method)
         return_annotation = signature.return_annotation
-        
+
         if return_annotation and return_annotation != inspect.Signature.empty:
             # Handle common type hints
-            if return_annotation == int:
-                return {"type": "integer"}
-            elif return_annotation == str:
-                return {"type": "string"}
-            elif return_annotation == bool:
-                return {"type": "boolean"}
-            elif return_annotation == float:
-                return {"type": "number"}
-            elif hasattr(return_annotation, '__origin__'):
+            if return_annotation in (int, str, bool, float):
+                return {
+                    int: {"type": "integer"},
+                    str: {"type": "string"},
+                    bool: {"type": "boolean"},
+                    float: {"type": "number"},
+                }[return_annotation]
+
+            if hasattr(return_annotation, "__origin__"):
                 # Handle generic types like List[str], Dict[str, Any]
                 origin = return_annotation.__origin__
                 if origin is list:
                     return {"type": "array", "items": {"type": "string"}}
-                elif origin is dict:
+                if origin is dict:
                     return {"type": "object"}
-            
+
     except Exception:
-        pass
+        logger.exception("Failed to extract schema from type hints")
     return None
 
 
@@ -111,18 +118,18 @@ def _analyze_method_source_code(serializer_class, method_name: str) -> dict:
         method = getattr(serializer_class, method_name, None)
         if not method:
             return None
-            
+
         source = inspect.getsource(method)
         tree = ast.parse(source)
-        
+
         # Find return statements and analyze them
         return_analyzer = ReturnStatementAnalyzer()
         return_analyzer.visit(tree)
-        
+
         return _infer_schema_from_return_patterns(return_analyzer.return_patterns)
-        
+
     except Exception:
-        pass
+        logger.exception("Failed to analyze method source code")
     return None
 
 
@@ -130,32 +137,39 @@ def _analyze_method_runtime(serializer_class, method_name: str) -> dict:
     """Analyze method by creating mock instances and examining return values."""
     try:
         # Create a basic mock object with common attributes
-        mock_obj = type('MockObj', (), {
-            'id': 1, 'pk': 1, 'name': 'test', 'count': lambda: 5,
-            'items': type('items', (), {'count': lambda: 3, 'all': lambda: []})()
-        })()
-        
+        mock_obj = type(
+            "MockObj",
+            (),
+            {
+                "id": 1,
+                "pk": 1,
+                "name": "test",
+                "count": lambda: 5,
+                "items": type("items", (), {"count": lambda: 3, "all": lambda: []})(),
+            },
+        )()
+
         serializer_instance = serializer_class()
         method = getattr(serializer_instance, method_name, None)
-        
+
         if not method:
             return None
-            
+
         # Execute method with mock data
         result = method(mock_obj)
         return _infer_schema_from_value(result)
-        
+
     except Exception:
-        pass
+        logger.exception("Failed to analyse method runtime")
     return None
 
 
 class ReturnStatementAnalyzer(ast.NodeVisitor):
     """AST visitor to analyze return statements in method source code."""
-    
+
     def __init__(self):
         self.return_patterns = []
-    
+
     def visit_Return(self, node):
         """Visit return statements and extract patterns."""
         if node.value:
@@ -163,92 +177,86 @@ class ReturnStatementAnalyzer(ast.NodeVisitor):
             if pattern:
                 self.return_patterns.append(pattern)
         self.generic_visit(node)
-    
+
     def _analyze_return_value(self, node) -> dict:
         """Analyze different types of return value patterns."""
         if isinstance(node, ast.Dict):
             return self._analyze_dict_return(node)
-        elif isinstance(node, ast.List):
+        if isinstance(node, ast.List):
             return self._analyze_list_return(node)
-        elif isinstance(node, ast.Constant):
+        if isinstance(node, ast.Constant):
             return self._analyze_constant_return(node)
-        elif isinstance(node, ast.Call):
+        if isinstance(node, ast.Call):
             return self._analyze_method_call_return(node)
-        elif isinstance(node, ast.Attribute):
+        if isinstance(node, ast.Attribute):
             return self._analyze_attribute_return(node)
         return None
-    
+
     def _analyze_dict_return(self, node) -> dict:
         """Analyze dictionary return patterns."""
         properties = {}
-        for key, value in zip(node.keys, node.values):
+        for key, value in zip(node.keys, node.values, strict=False):
             if isinstance(key, ast.Constant) and isinstance(key.value, str):
                 prop_schema = self._infer_value_type(value)
                 if prop_schema:
                     properties[key.value] = prop_schema
-        
-        return {
-            "type": "object",
-            "properties": properties
-        }
-    
+
+        return {"type": "object", "properties": properties}
+
     def _analyze_list_return(self, node) -> dict:
         """Analyze list return patterns."""
         if node.elts:
             # Analyze first element to determine array item type
             first_element_schema = self._infer_value_type(node.elts[0])
-            return {
-                "type": "array",
-                "items": first_element_schema or {"type": "string"}
-            }
+            return {"type": "array", "items": first_element_schema or {"type": "string"}}
         return {"type": "array", "items": {"type": "string"}}
-    
+
     def _analyze_constant_return(self, node) -> dict:
         """Analyze constant return values."""
         return self._python_type_to_schema(type(node.value))
-    
+
     def _analyze_method_call_return(self, node) -> dict:
         """Analyze method call returns (like obj.count(), obj.items.all())."""
         if isinstance(node.func, ast.Attribute):
             method_name = node.func.attr
-            
+
             # Common Django ORM patterns
-            if method_name in ['count']:
+            if method_name in ["count"]:
                 return {"type": "integer"}
-            elif method_name in ['all', 'filter', 'exclude']:
+            if method_name in ["all", "filter", "exclude"]:
                 return {"type": "array", "items": {"type": "object"}}
-            elif method_name in ['first', 'last', 'get']:
+            if method_name in ["first", "last", "get"]:
                 return {"type": "object"}
-            elif method_name in ['exists']:
+            if method_name in ["exists"]:
                 return {"type": "boolean"}
-        
+
         return None
-    
+
     def _analyze_attribute_return(self, node) -> dict:
         """Analyze attribute access returns (like obj.name, obj.id)."""
         if isinstance(node, ast.Attribute):
             attr_name = node.attr
-            
+
             # Common field name patterns
-            if attr_name in ['id', 'pk', 'count']:
+            if attr_name in ["id", "pk", "count"]:
                 return {"type": "integer"}
-            elif attr_name in ['name', 'title', 'description', 'slug']:
+            if attr_name in ["name", "title", "description", "slug"]:
                 return {"type": "string"}
-            elif attr_name in ['is_active', 'is_published', 'enabled']:
+            if attr_name in ["is_active", "is_published", "enabled"]:
                 return {"type": "boolean"}
-        
+
         return None
-    
+
     def _infer_value_type(self, node) -> dict:
         """Infer schema type from AST node."""
         if isinstance(node, ast.Constant):
             return self._python_type_to_schema(type(node.value))
-        elif isinstance(node, ast.Call):
+        if isinstance(node, ast.Call):
             return self._analyze_method_call_return(node)
-        elif isinstance(node, ast.Attribute):
+        if isinstance(node, ast.Attribute):
             return self._analyze_attribute_return(node)
         return {"type": "string"}  # Default fallback
-    
+
     def _python_type_to_schema(self, python_type) -> dict:
         """Convert Python type to OpenAPI schema."""
         type_mapping = {
@@ -266,20 +274,17 @@ def _infer_schema_from_return_patterns(patterns: list) -> dict:
     """Infer final schema from collected return patterns."""
     if not patterns:
         return None
-    
+
     # If all patterns are the same type, use that
-    if len(set(p.get("type") for p in patterns)) == 1:
+    if all(p.get("type") == patterns[0].get("type") for p in patterns):
         # Merge object properties if multiple object returns
         if patterns[0]["type"] == "object":
             merged_properties = {}
             for pattern in patterns:
                 merged_properties.update(pattern.get("properties", {}))
-            return {
-                "type": "object",
-                "properties": merged_properties
-            }
+            return {"type": "object", "properties": merged_properties}
         return patterns[0]
-    
+
     # Mixed types - could be union, but default to string for OpenAPI compatibility
     return {"type": "string"}
 
@@ -290,55 +295,47 @@ def _infer_schema_from_value(value: Any) -> dict:
         properties = {}
         for key, val in value.items():
             properties[str(key)] = _infer_schema_from_value(val)
-        return {
-            "type": "object",
-            "properties": properties
-        }
-    elif isinstance(value, list):
+        return {"type": "object", "properties": properties}
+    if isinstance(value, list):
         if value:
-            return {
-                "type": "array",
-                "items": _infer_schema_from_value(value[0])
-            }
+            return {"type": "array", "items": _infer_schema_from_value(value[0])}
         return {"type": "array", "items": {"type": "string"}}
-    elif isinstance(value, (int, float, str, bool)):
+    if type(value) in (int, float, str, bool):
         return {
             int: {"type": "integer"},
             float: {"type": "number"},
             str: {"type": "string"},
-            bool: {"type": "boolean"}
+            bool: {"type": "boolean"},
         }[type(value)]
-    else:
-        return {"type": "string"}
+    return {"type": "string"}
 
 
 def _get_serializer_class_from_schema_name(schema_name: str):
     """Try to get the serializer class from schema name."""
     try:
-        # Import Django and get all installed apps
-        import django
-        from django.apps import apps
-        from rest_framework import serializers
-        
         # Search through all apps for the serializer
         for app in apps.get_app_configs():
             app_module = app.module
             try:
                 # Try to import serializers module from the app
-                serializers_module = __import__(f"{app_module.__name__}.serializers", fromlist=[''])
-                
+                serializers_module = __import__(
+                    f"{app_module.__name__}.serializers", fromlist=[""]
+                )
+
                 # Look for serializer class matching the schema name
                 for attr_name in dir(serializers_module):
                     attr = getattr(serializers_module, attr_name)
-                    if (isinstance(attr, type) and 
-                        issubclass(attr, serializers.Serializer) and
-                        attr.__name__.replace('Serializer', '') in schema_name):
+                    if (
+                        isinstance(attr, type)
+                        and issubclass(attr, serializers.Serializer)
+                        and attr.__name__.replace("Serializer", "") in schema_name
+                    ):
                         return attr
             except ImportError:
                 continue
-                
+
     except Exception:
-        pass
+        logger.exception("Failed to get serializser.")
     return None
 
 
@@ -362,35 +359,38 @@ def schema_to_example_json(schema: dict, components: dict, for_response: bool =
     return _generate_example_by_type(schema, components, for_response)
 
 
-def _enhance_method_field_schema(schema: dict, components: dict) -> dict:
+def _enhance_method_field_schema(schema: dict, _components: dict) -> dict:
     """Enhance schema by analyzing SerializerMethodField types."""
-    if not isinstance(schema, dict) or 'properties' not in schema:
+    if not isinstance(schema, dict) or "properties" not in schema:
         return schema
-    
+
     # Try to get serializer class from schema title or other hints
-    schema_title = schema.get('title', '')
+    schema_title = schema.get("title", "")
     serializer_class = _get_serializer_class_from_schema_name(schema_title)
-    
+
     if not serializer_class:
         return schema
-    
+
     enhanced_properties = {}
-    for prop_name, prop_schema in schema['properties'].items():
+    for prop_name, prop_schema in schema["properties"].items():
         # Check if this looks like an unanalyzed SerializerMethodField
-        if (isinstance(prop_schema, dict) and 
-            prop_schema.get('type') == 'string' and 
-            not prop_schema.get('enum') and 
-            not prop_schema.get('format') and
-            not prop_schema.get('example')):
-            
+        if (
+            isinstance(prop_schema, dict)
+            and prop_schema.get("type") == "string"
+            and not prop_schema.get("enum")
+            and not prop_schema.get("format")
+            and not prop_schema.get("example")
+        ):
             # Try to analyze the method field
-            analyzed_schema = analyze_serializer_method_field_schema(serializer_class, prop_name)
+            analyzed_schema = analyze_serializer_method_field_schema(
+                serializer_class, prop_name
+            )
             enhanced_properties[prop_name] = analyzed_schema
         else:
             enhanced_properties[prop_name] = prop_schema
-    
+
     enhanced_schema = schema.copy()
-    enhanced_schema['properties'] = enhanced_properties
+    enhanced_schema["properties"] = enhanced_properties
     return enhanced_schema
 
 
@@ -942,4 +942,3 @@ def create_endpoints_index(
         ]
     )
     generator.create_endpoints_index(endpoints_by_app, docs_dir)
-

drf_to_mkdoc/utils/extractors/query_parameter_extractors.py

@@ -1,9 +1,7 @@
-#!/usr/bin/env python3
-
-"""Query parameter extraction utilities for Django views."""
-
 from typing import Any
 
+import django_filters
+
 from drf_to_mkdoc.utils.common import extract_viewset_from_operation_id
 
 
@@ -51,7 +49,7 @@ def extract_query_parameters_from_view_filter_fields(view_class: Any) -> list[st
     elif hasattr(view_class, "filterset_fields") and view_class.filterset_fields:
         filter_fields = sorted(view_class.filterset_fields)
 
-    return filter_fields
+    return list(set(filter_fields))
 
 
 def extract_query_parameters_from_view_ordering_fields(view_class: Any) -> list[str]:
@@ -116,8 +114,6 @@ def _extract_filterset_fields_from_class_attributes(filterset_class: Any) -> lis
     fields = []
 
     try:
-        import django_filters
-
         # Get all class attributes, including inherited ones
         for attr_name in dir(filterset_class):
             # Skip private attributes and known non-filter attributes

{drf_to_mkdoc-0.1.6.dist-info → drf_to_mkdoc-1.0.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drf-to-mkdoc
-Version: 0.1.6
+Version: 1.0.7
 Summary: Generate Markdown API docs from Django/DRF OpenAPI schema for MkDocs
 Author-email: Hossein Shayesteh <shayestehhs1@gmail.com>
 Maintainer-email: Hossein Shayesteh <shayestehhs1@gmail.com>

{drf_to_mkdoc-0.1.6.dist-info → drf_to_mkdoc-1.0.7.dist-info}/RECORD

@@ -1,14 +1,14 @@
-drf_to_mkdoc/__init__.py,sha256=j7qOxIbkDy7oit4Tb3NZUqbqkrxKz07PeN9QuF3Qp9s,179
-drf_to_mkdoc/apps.py,sha256=0TLecPHZ8vf0IhAVFh1oIIHQbhx5lVto7qrvStx3R1Y,464
+drf_to_mkdoc/__init__.py,sha256=IbTW5uKQvJRG9ncHRuk_AGKHPn4ruxs5LqDpUFgUhws,180
+drf_to_mkdoc/apps.py,sha256=-NrC_dRr6GmLmNQhkNh819B7V1SS4DYDv5JOR0TtuJM,560
 drf_to_mkdoc/conf/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-drf_to_mkdoc/conf/defaults.py,sha256=9OK65SeP4aLZbuRJBAE_QeC-OhXkh0cACBqax6wYXnM,576
-drf_to_mkdoc/conf/settings.py,sha256=OgB3MCn4Z5F4xqWP34kwzMs50kRn3qF0gE1zS2SHS2M,1550
+drf_to_mkdoc/conf/defaults.py,sha256=hEjQdN3WsT539UWhFkylI60piykV_7BDudLPNd_E8PE,575
+drf_to_mkdoc/conf/settings.py,sha256=Gz2Ye5AmPRtOZ3R71IraeK2xBndqEezos9W9xPWYRPY,1513
 drf_to_mkdoc/management/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 drf_to_mkdoc/management/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-drf_to_mkdoc/management/commands/build_docs.py,sha256=p--TajkpYU-hmthXp5eVmVtJnXLxZrfQWQmuzwOgl0c,2491
+drf_to_mkdoc/management/commands/build_docs.py,sha256=QUDE6ROwT6LYAfCc4MkzJZANkGF1BdAQIHfvUwuLYG4,4053
 drf_to_mkdoc/management/commands/generate_doc_json.py,sha256=mWdYgMbSeLP4iQZeUm2DxwYQmdGy8w05XTEfbT_nOJo,19833
-drf_to_mkdoc/management/commands/generate_docs.py,sha256=YGdejd-b1Wn_e5ru9orwp1b9H5PZwVWkuWxAY1JyG88,4897
-drf_to_mkdoc/management/commands/generate_model_docs.py,sha256=rtgg77StIg0MomWx8ZAZY6SuFZ_m5ZFQmc0K-RrMw4I,13420
+drf_to_mkdoc/management/commands/generate_docs.py,sha256=JWoMYvfvjYq_Rlmi7RRFfjJ6qsRjI1K-7B5w-qmjMe8,4896
+drf_to_mkdoc/management/commands/generate_model_docs.py,sha256=A_Q6o10kfy-GN_ZDD9YS6jv3RTyxBy28DEsi5qKZZoU,13421
 drf_to_mkdoc/management/commands/update_doc_schema.py,sha256=TtHVQxnVpB_VELRkVcdsDXDU5zXdguFleB1mXCDMAbg,2009
 drf_to_mkdoc/static/drf-to-mkdoc/javascripts/endpoints-filter.js,sha256=KtfWroqsXg-wwmk36hpoH--M9WIW85EFNGeswMjFu4g,6138
 drf_to_mkdoc/static/drf-to-mkdoc/stylesheets/extra.css,sha256=jR52Kyld8fbHCUSehgU0DONcGnjTkqihQqiAXkAvflU,8024
@@ -29,15 +29,15 @@ drf_to_mkdoc/static/drf-to-mkdoc/stylesheets/endpoints/tags.css,sha256=dOw13qsvV
 drf_to_mkdoc/static/drf-to-mkdoc/stylesheets/endpoints/theme-toggle.css,sha256=atnaTx7Ed6YZ0sIfofYBf8wOfUzlLCynrBDMAjHJF58,676
 drf_to_mkdoc/static/drf-to-mkdoc/stylesheets/endpoints/variables.css,sha256=JJpvo4MoEsPEiFfugNDbPWvYAGDh0kE1jEl804dX3sk,830
 drf_to_mkdoc/utils/__init__.py,sha256=6dFTb07S6yIf-INMy0Mlgf5purNir687ZU9WZtITh4k,68
-drf_to_mkdoc/utils/common.py,sha256=FnqnEgQkIvXy05zG_xGFm4rmJ1pXURszHGbkuNoNa-4,11750
-drf_to_mkdoc/utils/endpoint_generator.py,sha256=oGHQXJB5VFlGOq6W8a3q96CwF3conjBe_tkYj6m2mlg,35849
+drf_to_mkdoc/utils/common.py,sha256=LHq2MjqURLK6VOXNfjWXPADXPDYxxYbcmLZs9jIg36Y,11744
+drf_to_mkdoc/utils/endpoint_generator.py,sha256=2V63lvik_dlxLZ0P4WrNe77iboFLKpUZ9VJAL758tC4,35716
 drf_to_mkdoc/utils/model_generator.py,sha256=O1ibaw7KmL_fQ1OTebuk6Tt2yTjyElpyF7bN8gk5LBE,9588
 drf_to_mkdoc/utils/extractors/__init__.py,sha256=BvC8gKOPVI9gU1Piw0jRhKQ2ER5s1moAxgq7ZYkJWNI,86
-drf_to_mkdoc/utils/extractors/query_parameter_extractors.py,sha256=9t6NbafXIsbKxquh7VrpnsYOJ70YAsL9fgu_7dSXr5Y,8577
+drf_to_mkdoc/utils/extractors/query_parameter_extractors.py,sha256=-u9TG1hDKVExanypyWM7wQGG9vo80WrfVLbaPXv-Bc4,8494
 drf_to_mkdoc/utils/md_generators/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 drf_to_mkdoc/utils/md_generators/query_parameters_generators.py,sha256=N-XqZ_FUODSR5V4xM9oEA3aaIiNGNmNwpvrWbQTx6RI,2566
-drf_to_mkdoc-0.1.6.dist-info/licenses/LICENSE,sha256=3n9_ckIREsH8ogCxWW6dFsw_WfGcluG2mHcgl9i_UU0,1068
-drf_to_mkdoc-0.1.6.dist-info/METADATA,sha256=GR296N3kUCyXgQGfkvu1AS1_UnM283eCVHUuEfKTUys,7304
-drf_to_mkdoc-0.1.6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-drf_to_mkdoc-0.1.6.dist-info/top_level.txt,sha256=ZzJecR6j_tvLZiubUBEgawHflozC4DQy9ooNf1yDJ3Q,13
-drf_to_mkdoc-0.1.6.dist-info/RECORD,,
+drf_to_mkdoc-1.0.7.dist-info/licenses/LICENSE,sha256=3n9_ckIREsH8ogCxWW6dFsw_WfGcluG2mHcgl9i_UU0,1068
+drf_to_mkdoc-1.0.7.dist-info/METADATA,sha256=VBPSLEF8EX1LaRDMe31AhZoihyEPBTQcW_50z9lL2lM,7304
+drf_to_mkdoc-1.0.7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+drf_to_mkdoc-1.0.7.dist-info/top_level.txt,sha256=ZzJecR6j_tvLZiubUBEgawHflozC4DQy9ooNf1yDJ3Q,13
+drf_to_mkdoc-1.0.7.dist-info/RECORD,,