drf-to-mkdoc 0.1.9__tar.gz → 0.2.1__tar.gz

{drf_to_mkdoc-0.1.9 → drf_to_mkdoc-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drf-to-mkdoc
-Version: 0.1.9
+Version: 0.2.1
 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>
@@ -76,13 +76,14 @@ INSTALLED_APPS = [
 
 # Required for OpenAPI schema generation
 REST_FRAMEWORK = {
-    'DEFAULT_SCHEMA_CLASS': 'drf_spectacular.openapi.AutoSchema',
+    'DEFAULT_SCHEMA_CLASS': 'drf_to_mkdoc.utils.schema.AutoSchema',  # Use our custom AutoSchema
 }
 
 SPECTACULAR_SETTINGS = {
     'TITLE': 'Your API',
     'DESCRIPTION': 'Your API description',
     'VERSION': '1.0.0',
+
 }
 
 DRF_TO_MKDOC = {
@@ -110,10 +111,19 @@ DRF_TO_MKDOC = {
 python manage.py build_docs --settings=docs_settings
 ```
 
+## Available Commands
+
+- `build_docs`: Build the complete documentation site with MkDocs
+- `build_endpoint_docs`: Build endpoint documentation from OpenAPI schema
+- `build_model_docs`: Build model documentation from model JSON data
+- `extract_model_data`: Extract model data from Django model introspection and save as JSON
+- `update_doc_schema`: Update the final schema by copying the documented schema
+
 ## What you get
 
 See a detailed overview of generated files in `docs/structure.md` and a feature breakdown in `docs/features.md`.
 
+
 ## How it works
 
 Under the hood, drf-to-mkdoc introspects your models and reads your DRF OpenAPI schema to generate clean, organized Markdown. Then MkDocs turns it into a polished static site. Always current, no manual updates.
@@ -154,8 +164,9 @@ drf-to-mkdoc/
 │   ├── management/
 │   │   └── commands/
 │   │       ├── build_docs.py           # Build MkDocs site
-│   │       ├── generate_docs.py        # Main documentation generator
-│   │       ├── generate_model_docs.py  # Model documentation
+│   │       ├── build_endpoint_docs.py  # Build endpoint documentation
+│   │       ├── build_model_docs.py     # Build model documentation
+│   │       ├── extract_model_data.py   # Extract model data from Django
 │   │       └── update_doc_schema.py    # Schema updates
 │   └── utils/
 │       ├── common.py        # Shared utilities
@@ -222,4 +233,4 @@ your-project/
 ## Contributing
 
 See [CONTRIBUTING.md](CONTRIBUTING.md) for detailed contribution guidelines. 
-This will ensure that only the source configuration and scripts are versioned, while the generated documentation is excluded. 
+This will ensure that only the source configuration and scripts are versioned, while the generated documentation is excluded.

{drf_to_mkdoc-0.1.9 → drf_to_mkdoc-0.2.1}/README.md

@@ -27,13 +27,14 @@ INSTALLED_APPS = [
 
 # Required for OpenAPI schema generation
 REST_FRAMEWORK = {
-    'DEFAULT_SCHEMA_CLASS': 'drf_spectacular.openapi.AutoSchema',
+    'DEFAULT_SCHEMA_CLASS': 'drf_to_mkdoc.utils.schema.AutoSchema',  # Use our custom AutoSchema
 }
 
 SPECTACULAR_SETTINGS = {
     'TITLE': 'Your API',
     'DESCRIPTION': 'Your API description',
     'VERSION': '1.0.0',
+
 }
 
 DRF_TO_MKDOC = {
@@ -61,10 +62,19 @@ DRF_TO_MKDOC = {
 python manage.py build_docs --settings=docs_settings
 ```
 
+## Available Commands
+
+- `build_docs`: Build the complete documentation site with MkDocs
+- `build_endpoint_docs`: Build endpoint documentation from OpenAPI schema
+- `build_model_docs`: Build model documentation from model JSON data
+- `extract_model_data`: Extract model data from Django model introspection and save as JSON
+- `update_doc_schema`: Update the final schema by copying the documented schema
+
 ## What you get
 
 See a detailed overview of generated files in `docs/structure.md` and a feature breakdown in `docs/features.md`.
 
+
 ## How it works
 
 Under the hood, drf-to-mkdoc introspects your models and reads your DRF OpenAPI schema to generate clean, organized Markdown. Then MkDocs turns it into a polished static site. Always current, no manual updates.
@@ -105,8 +115,9 @@ drf-to-mkdoc/
 │   ├── management/
 │   │   └── commands/
 │   │       ├── build_docs.py           # Build MkDocs site
-│   │       ├── generate_docs.py        # Main documentation generator
-│   │       ├── generate_model_docs.py  # Model documentation
+│   │       ├── build_endpoint_docs.py  # Build endpoint documentation
+│   │       ├── build_model_docs.py     # Build model documentation
+│   │       ├── extract_model_data.py   # Extract model data from Django
 │   │       └── update_doc_schema.py    # Schema updates
 │   └── utils/
 │       ├── common.py        # Shared utilities
@@ -173,4 +184,4 @@ your-project/
 ## Contributing
 
 See [CONTRIBUTING.md](CONTRIBUTING.md) for detailed contribution guidelines. 
-This will ensure that only the source configuration and scripts are versioned, while the generated documentation is excluded. 
+This will ensure that only the source configuration and scripts are versioned, while the generated documentation is excluded.

drf_to_mkdoc-0.2.1/docs/customizing_endpoints.md

@@ -0,0 +1,173 @@
+
+# Customizing API Endpoint Documentation
+
+`drf-to-mkdoc` automatically generates API documentation from your Django REST Framework (DRF) project using the OpenAPI schema from **DRF Spectacular**. You can refine and extend that documentation using a **custom JSON file**.
+
+---
+
+## 1. Where to put your custom schema
+
+By default, the generator looks for:
+docs/configs/custom\_schema.json
+
+
+
+
+You can change this path by setting `CUSTOM_SCHEMA_FILE` in your `DRF_TO_MKDOC` settings.
+
+---
+
+## 2. JSON File Format
+
+The file should be a JSON object where **keys are `operationId`s** from your OpenAPI schema. Each key can override or extend the operation’s documentation.
+
+Supported fields for each operation:
+
+- `description` → Text description of the endpoint  
+- `parameters` → Array of OpenAPI parameter objects  
+- `requestBody` → OpenAPI RequestBody object  
+- `responses` → OpenAPI Responses object  
+- `append_fields` → A list of keys that should **append to existing lists instead of replacing them**.  
+   - Currently, this is only useful for fields that are arrays in the schema (e.g., `parameters`).  
+   - If the target field is not a list (like `description`, `responses`, or `requestBody`), `append_fields` is ignored and the value is replaced as usual.  
+   - Example: If you want to **keep auto-generated query parameters** and add your own, include `"parameters"` in `append_fields`.  
+
+---
+
+### Example `custom_schema.json` using all supported keys
+
+```json
+{
+  "clinic_panel_appointments_available_appointment_times_list": {
+    "description": "Shows all available appointment times for a clinic.",
+    "parameters": [
+      {
+        "name": "date",
+        "in": "query",
+        "description": "Filter appointments by date",
+        "required": false,
+        "schema": { "type": "string", "format": "date" },
+        "queryparam_type": "filter_fields"
+      },
+      {
+        "name": "search",
+        "in": "query",
+        "description": "Search appointments by doctor or patient name",
+        "required": false,
+        "schema": { "type": "string" },
+        "queryparam_type": "search_fields"
+      }
+    ],
+    "requestBody": {
+      "description": "Request body for creating an appointment",
+      "required": true,
+      "content": {
+        "application/json": {
+          "schema": {
+            "type": "object",
+            "properties": {
+              "doctor_id": { "type": "integer" },
+              "patient_id": { "type": "integer" },
+              "date": { "type": "string", "format": "date" },
+              "time_slot": { "type": "string" }
+            },
+            "required": ["doctor_id", "patient_id", "date", "time_slot"]
+          }
+        }
+      }
+    },
+    "responses": {
+      "200": {
+        "description": "List of available time slots",
+        "content": {
+          "application/json": {
+            "schema": {
+              "type": "array",
+              "items": {
+                "type": "object",
+                "properties": {
+                  "date": { "type": "string", "description": "Date in DATE_FORMAT" },
+                  "time_slots": {
+                    "type": "array",
+                    "items": {
+                      "type": "object",
+                      "properties": {
+                        "start_datetime": { "type": "string", "description": "Start datetime" },
+                        "end_datetime": { "type": "string", "description": "End datetime" }
+                      },
+                      "required": ["start_datetime", "end_datetime"]
+                    },
+                    "description": "Available time slots for the date"
+                  }
+                },
+                "required": ["date", "time_slots"]
+              }
+            }
+          }
+        }
+      },
+      "404": {
+        "description": "No appointments found for the given filters",
+        "content": {
+          "application/json": {
+            "schema": {
+              "type": "object",
+              "properties": {
+                "detail": { "type": "string", "example": "Appointments not found" }
+              },
+              "required": ["detail"]
+            }
+          }
+        }
+      }
+    },
+    "append_fields": ["parameters"]
+  }
+}
+````
+
+---
+
+## 3. Adding Query Parameters
+
+If you add a **query parameter** (`"in": "query"`), include a `queryparam_type` so it’s categorized properly in the generated docs.
+
+Supported `queryparam_type` values:
+
+* `search_fields` → Used for search filters
+* `filter_fields` → Standard filters
+* `ordering_fields` → Sort fields
+* `filter_backends` → Backend-specific filters
+* `pagination_fields` → Pagination-related fields
+
+> ⚠️ If `queryparam_type` is missing or invalid, the generator will raise an error.
+
+---
+
+## 4. How the custom schema is applied
+
+1. `drf-to-mkdoc` loads your OpenAPI schema.
+2. It reads your `custom_schema.json`.
+3. For each `operationId` in your JSON:
+
+   * Finds the corresponding endpoint in the schema
+   * Replaces fields like `description`, `responses`, `parameters`, etc.
+   * Appends items for fields listed in `append_fields` instead of replacing
+4. Generates your markdown documentation using the merged schema
+
+---
+
+## 5. Finding `operationId`s
+
+`operationId`s are generated by DRF Spectacular. You can find them by:
+
+* Checking your API endpoint pages in the browser (each includes the `operationId`)
+* Inspecting the OpenAPI JSON/YAML schema (via `/schema/` endpoint or export)
+
+---
+
+## 6. Tips for smooth usage
+
+* Keep `custom_schema.json` in version control so your team benefits.
+* Start small: add descriptions first, then parameters, then responses.
+* Use `append_fields` if you want to **add extra info** without overwriting auto-generated items.

{drf_to_mkdoc-0.1.9 → drf_to_mkdoc-0.2.1}/docs/serving_mkdocs_with_django.md

@@ -65,30 +65,45 @@ class DocumentationView(View):
             raise Http404("Invalid path")
 
         file_path = (site_dir / path).resolve()
-        site_root = site_dir.resolve()
 
-        # Ensure file is inside site dir and exists
-        if not str(file_path).startswith(str(site_root)):
-            raise Http404("Access denied")
-        if not file_path.exists() or not file_path.is_file():
-            raise Http404("Documentation file not found")
+        # Ensure the file exists and is within the site directory
+        try:
+            file_path = file_path.resolve()
+            site_dir = site_dir.resolve()
 
+            # Security check: ensure file is within site directory
+            if not str(file_path).startswith(str(site_dir)):
+                return HttpResponseRedirect("/docs/404/index.html?error=access_denied")
+
+            if not file_path.exists() or not file_path.is_file():
+                return HttpResponseRedirect("/docs/404/index.html")
+
+        except (OSError, ValueError) as e:
+                return HttpResponseRedirect("/docs/404/index.html?error=invalid_file_path")
+
+        # Determine content type
         content_type, _ = mimetypes.guess_type(str(file_path))
         if content_type is None:
             content_type = "application/octet-stream"
 
-        with file_path.open("rb") as f:
-            response = HttpResponse(f.read(), content_type=content_type)
-
-        # Cache headers (tweak as needed)
-        if content_type.startswith("text/html"):
-            response["Cache-Control"] = "no-cache, no-store, must-revalidate"
-            response["Pragma"] = "no-cache"
-            response["Expires"] = "0"
+        # Read and serve the file
+        try:
+            with Path(file_path).open("rb") as f:
+                response = HttpResponse(f.read(), content_type=content_type)
+
+            # Set appropriate headers
+            if content_type.startswith("text/html"):
+                response["Cache-Control"] = "no-cache, no-store, must-revalidate"
+                response["Pragma"] = "no-cache"
+                response["Expires"] = "0"
+            else:
+                response["Cache-Control"] = "public, max-age=3600"
+
+        except OSError as e:
+            return HttpResponseRedirect("/docs/404/index.html?error=could_not_read_file")
         else:
-            response["Cache-Control"] = "public, max-age=3600"
+            return response
 
-        return response
 ```
 
 ## Permission options

{drf_to_mkdoc-0.1.9 → drf_to_mkdoc-0.2.1}/drf_to_mkdoc/conf/defaults.py

@@ -7,6 +7,11 @@ DEFAULTS = {
     "CUSTOM_SCHEMA_FILE": "docs/configs/custom_schema.json",  # Path to custom schema file
     "PATH_PARAM_SUBSTITUTE_FUNCTION": None,
     "PATH_PARAM_SUBSTITUTE_MAPPING": {},
+    # AI documentation settings
+    "ENABLE_AI_DOCS": False,
+    "AI_CONFIG_DIR_NAME": "ai_code",  # Directory name for AI-generated code files
+    "AI_OPERATION_MAP_FILE": "docs/configs/operation_map.json",  # Path to operation map file
+    "SERIALIZERS_INHERITANCE_DEPTH": 1,  # Maximum depth for class inheritance analysis
     # Django apps - required, no default
     "DJANGO_APPS": None,  # List of Django app names to process
 }

drf_to_mkdoc-0.2.1/drf_to_mkdoc/conf/settings.py

@@ -0,0 +1,164 @@
+from pathlib import Path
+from typing import Any, ClassVar
+
+from django.conf import settings
+
+from drf_to_mkdoc.conf.defaults import DEFAULTS
+
+
+class DRFToMkDocSettings:
+    required_settings: ClassVar[list[str]] = ["DJANGO_APPS"]
+    project_settings: ClassVar[dict[str, Any]] = {"PROJECT_NAME": "drf-to-mkdoc"}
+
+    settings_types: ClassVar[dict[str, type]] = {
+        "ENABLE_AI_DOCS": bool,
+        "AI_CONFIG_DIR_NAME": str,
+        "SERIALIZERS_INHERITANCE_DEPTH": int,
+    }
+
+    settings_ranges: ClassVar[dict[str, tuple[int, int]]] = {
+        "SERIALIZERS_INHERITANCE_DEPTH": (1, 3),
+    }
+
+    path_settings = {
+        "CONFIG_DIR",
+        "MODEL_DOCS_FILE",
+        "DOC_CONFIG_FILE",
+        "CUSTOM_SCHEMA_FILE",
+        "AI_OPERATION_MAP_FILE",
+    }
+
+    def __init__(self, user_settings_key="DRF_TO_MKDOC", defaults=None):
+        self.user_settings_key = user_settings_key
+        self._user_settings = getattr(settings, user_settings_key, {})
+        self.defaults = defaults or {}
+
+    def _validate_type(self, key: str, value: Any) -> None:
+        """Validate the type of setting value."""
+        if key in self.settings_types:
+            expected_type = self.settings_types[key]
+            if not isinstance(value, expected_type):
+                raise TypeError(
+                    f"DRF_TO_MKDOC setting '{key}' must be of type {expected_type.__name__}, "
+                    f"got {type(value).__name__} instead."
+                )
+
+    def _validate_range(self, key: str, value: Any) -> None:
+        """Validate the range of a setting value."""
+        if key in self.settings_ranges:
+            min_val, max_val = self.settings_ranges[key]
+            if not min_val <= value <= max_val:
+                raise ValueError(
+                    f"DRF_TO_MKDOC setting '{key}' must be between {min_val} and {max_val}, "
+                    f"got {value} instead."
+                )
+
+    def _validate_required(self, key: str, value: Any) -> None:
+        """Validate if a required setting is configured."""
+        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}."
+            )
+
+    def _validate_dir(self, key: str, value: str) -> None:
+        if key not in self.path_settings or not isinstance(value, str):
+            return
+
+        if not value.strip():
+            raise ValueError(
+                f"DRF_TO_MKDOC path setting '{key}' cannot be empty or contain only whitespace."
+            )
+
+        dangerous_components = {"..", "~", "/", "\\"}
+        path_parts = Path(value).parts
+        for part in path_parts:
+            if part in dangerous_components or part.startswith("."):
+                raise ValueError(
+                    f"DRF_TO_MKDOC path setting '{key}' contains unsafe path component '{part}'. "
+                    f"Directory names should be simple names without separators or relative path components."
+                )
+
+        if Path(value).is_absolute():
+            raise ValueError(
+                f"DRF_TO_MKDOC path setting '{key}' cannot be an absolute path. "
+                f"Use relative directory names only."
+            )
+
+        reserved_names = {
+            "CON",
+            "PRN",
+            "AUX",
+            "NUL",
+            "COM1",
+            "COM2",
+            "COM3",
+            "COM4",
+            "COM5",
+            "COM6",
+            "COM7",
+            "COM8",
+            "COM9",
+            "LPT1",
+            "LPT2",
+            "LPT3",
+            "LPT4",
+            "LPT5",
+            "LPT6",
+            "LPT7",
+            "LPT8",
+            "LPT9",
+        }
+        if value.upper() in reserved_names:
+            raise ValueError(
+                f"DRF_TO_MKDOC path setting '{key}' uses a reserved system name '{value}'. "
+                f"Please choose a different name."
+            )
+
+        invalid_chars = '<>:"|?*'
+        if any(char in value for char in invalid_chars):
+            raise ValueError(
+                f"DRF_TO_MKDOC path setting '{key}' contains invalid characters. "
+                f"Avoid using: {invalid_chars}"
+            )
+
+    def get(self, key):
+        if key in self.project_settings:
+            return self.project_settings[key]
+
+        # User-provided settings take precedence
+        if key in self._user_settings:
+            value = self._user_settings[key]
+        else:
+            value = self.defaults.get(key, None)
+
+        # Run all validations
+        self._validate_required(key, value)
+        self._validate_type(key, value)
+        self._validate_range(key, value)
+        self._validate_dir(key, value)
+
+        if value is None:
+            raise AttributeError(f"Invalid DRF_TO_MKDOC setting: '{key}'")
+        return value
+
+    def __getattr__(self, key):
+        return self.get(key)
+
+    def validate_required_settings(self):
+        missing_settings = []
+
+        for setting in self.required_settings:
+            try:
+                self.get(setting)
+            except (ValueError, AttributeError):
+                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-0.1.9 → drf_to_mkdoc-0.2.1}/drf_to_mkdoc/management/commands/build_docs.py

@@ -34,15 +34,16 @@ class Command(BaseCommand):
             )
 
         try:
-            # Generate the model documentation JSON first
-            self.stdout.write("Generating model documentation...")
-            call_command("generate_model_docs", "--pretty")
-            self.stdout.write(self.style.SUCCESS("Model documentation generated."))
+            # Extract model data from Django models
+            self.stdout.write("Extracting model data...")
+            call_command("extract_model_data", "--pretty")
+            self.stdout.write(self.style.SUCCESS("Model data extracted."))
 
             # Generate the documentation content
-            self.stdout.write("Generating documentation content...")
-            call_command("generate_docs")
-            self.stdout.write(self.style.SUCCESS("Documentation content generated."))
+            self.stdout.write("Building documentation content...")
+            call_command("build_model_docs")
+            call_command("build_endpoint_docs")
+            self.stdout.write(self.style.SUCCESS("Documentation content built."))
 
             # Build the MkDocs site
             self.stdout.write("Building MkDocs site...")

drf_to_mkdoc-0.2.1/drf_to_mkdoc/management/commands/build_endpoint_docs.py

@@ -0,0 +1,69 @@
+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.commons.schema_utils import get_schema
+from drf_to_mkdoc.utils.endpoint_detail_generator import (
+    generate_endpoint_files,
+    parse_endpoints_from_schema,
+)
+from drf_to_mkdoc.utils.endpoint_list_generator import create_endpoints_index
+
+
+class Command(BaseCommand):
+    help = "Build endpoint documentation from OpenAPI schema"
+
+    def handle(self, *args, **options):
+        self.stdout.write(
+            self.style.SUCCESS("🚀 Starting endpoint documentation generation...")
+        )
+
+        docs_dir = self._setup_docs_directory()
+        schema_data = self._load_schema_data()
+
+        if schema_data:
+            self._generate_endpoints_documentation(schema_data, docs_dir)
+            self.stdout.write(
+                self.style.SUCCESS("✅ Endpoint documentation generation complete!")
+            )
+        else:
+            self.stdout.write(self.style.ERROR("❌ Failed to generate endpoint documentation."))
+
+    def _setup_docs_directory(self):
+        docs_dir = Path(drf_to_mkdoc_settings.DOCS_DIR)
+        docs_dir.mkdir(parents=True, exist_ok=True)
+        return docs_dir
+
+    def _load_schema_data(self):
+        try:
+            schema = get_schema()
+        except Exception as e:
+            self.stdout.write(self.style.ERROR(f"❌ Failed to load OpenAPI schema: {e}"))
+            return {}
+        if not schema:
+            self.stdout.write(self.style.ERROR("❌ Failed to load OpenAPI schema"))
+            return {}
+
+        paths = schema.get("paths", {})
+        components = schema.get("components", {})
+
+        self.stdout.write(f"📊 Loaded {len(paths)} API paths")
+
+        return {"paths": paths, "components": components}
+
+    def _generate_endpoints_documentation(self, schema_data, docs_dir):
+        self.stdout.write("🔗 Generating endpoint documentation...")
+
+        paths = schema_data["paths"]
+        components = schema_data["components"]
+
+        endpoints_by_app = parse_endpoints_from_schema(paths)
+        total_endpoints = generate_endpoint_files(endpoints_by_app, components)
+        create_endpoints_index(endpoints_by_app, docs_dir)
+
+        self.stdout.write(
+            self.style.SUCCESS(
+                f"✅ Generated {total_endpoints} endpoint files with Django view introspection"
+            )
+        )

drf_to_mkdoc-0.2.1/drf_to_mkdoc/management/commands/build_model_docs.py

@@ -0,0 +1,50 @@
+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.commons.file_utils import load_json_data
+from drf_to_mkdoc.utils.model_detail_generator import generate_model_docs
+from drf_to_mkdoc.utils.model_list_generator import create_models_index
+
+
+class Command(BaseCommand):
+    help = "Build model documentation from model JSON data"
+
+    def handle(self, *args, **options):
+        self.stdout.write(self.style.SUCCESS("🚀 Starting model documentation generation..."))
+
+        docs_dir = self._setup_docs_directory()
+        models_data = self._load_models_data()
+
+        if models_data:
+            self._generate_models_documentation(models_data, docs_dir)
+            self.stdout.write(self.style.SUCCESS("✅ Model documentation generation complete!"))
+        else:
+            self.stdout.write(self.style.ERROR("❌ Failed to generate model documentation."))
+
+    def _setup_docs_directory(self):
+        docs_dir = Path(drf_to_mkdoc_settings.DOCS_DIR)
+        docs_dir.mkdir(parents=True, exist_ok=True)
+        return docs_dir
+
+    def _load_models_data(self):
+        models_data = load_json_data(
+            drf_to_mkdoc_settings.MODEL_DOCS_FILE, raise_not_found=False
+        )
+
+        if not models_data:
+            self.stdout.write(self.style.WARNING("⚠️  No model data found"))
+
+        return models_data
+
+    def _generate_models_documentation(self, models_data, docs_dir):
+        self.stdout.write("📋 Generating model documentation...")
+
+        try:
+            generate_model_docs(models_data)
+            create_models_index(models_data, docs_dir)
+            self.stdout.write(self.style.SUCCESS("✅ Model documentation generated"))
+        except Exception as e:
+            self.stdout.write(self.style.WARNING(f"⚠️  Failed to generate model docs: {e}"))
+            raise