drf-to-mkdoc 0.2.1__py3-none-any.whl → 0.2.3__py3-none-any.whl

drf_to_mkdoc/utils/endpoint_list_generator.py

@@ -1,6 +1,7 @@
 from pathlib import Path
 from typing import Any
 
+from django.template.loader import render_to_string
 from django.templatetags.static import static
 
 from drf_to_mkdoc.conf.settings import drf_to_mkdoc_settings
@@ -9,211 +10,75 @@ from drf_to_mkdoc.utils.commons.operation_utils import extract_viewset_from_oper
 
 class EndpointsIndexGenerator:
     def __init__(self, active_filters: list[str] | None = None):
-        self.active_filters = set(
-            active_filters
-            or [
-                "method",
-                "path",
-                "app",
-                "models",
-                "auth",
-                "roles",
-                "content_type",
-                "params",
-                "schema",
-                "pagination",
-                "ordering",
-                "search",
-                "tags",
-            ]
-        )
-
-    def create_endpoint_card(
-        self, endpoint: dict[str, Any], app_name: str, viewset_name: str
-    ) -> str:
-        method = endpoint["method"]
-        path = endpoint["path"]
-        filename = endpoint["filename"]
-        view_class = extract_viewset_from_operation_id(endpoint["operation_id"])
-
-        link_url = f"{app_name}/{viewset_name.lower()}/{filename}".replace(".md", "/index.html")
-        data_attrs = f"""
-            data-method="{method.lower()}"
-            data-path="{path.lower()}"
-            data-app="{app_name.lower()}"
-            data-auth="{str(endpoint.get("auth_required", False)).lower()}"
-            data-pagination="{str(endpoint.get("pagination_support", False)).lower()}"
-            data-search="{str(bool(getattr(view_class, "search_fields", []))).lower()}"
-            data-ordering="{str(endpoint.get("ordering_support", False)).lower()}"
-            data-models="{" ".join(endpoint.get("related_models", [])).lower()}"
-            data-roles="{" ".join(endpoint.get("permission_roles", [])).lower()}"
-            data-content-type="{endpoint.get("content_type", "").lower()}"
-            data-tags="{" ".join(endpoint.get("tags", [])).lower()}"
-            data-schema="{" ".join(endpoint.get("schema_fields", [])).lower()}"
-            data-params="{" ".join(endpoint.get("query_parameters", [])).lower()}"
-        """.strip()
-
-        return f"""
-    <a href="{link_url}" class="endpoint-card" {data_attrs}>
-        <span class="method-badge method-{method.lower()}">{method}</span>
-        <span class="endpoint-path">{path}</span>
-    </a>
-    """
-
-    def create_filter_section(self) -> str:
-        filter_fields = {
-            "method": """<div class="filter-group">
-                <label class="filter-label">HTTP Method</label>
-                <select id="filter-method" class="filter-select">
-                    <option value="">All</option>
-                    <option value="get">GET</option>
-                    <option value="post">POST</option>
-                    <option value="put">PUT</option>
-                    <option value="patch">PATCH</option>
-                    <option value="delete">DELETE</option>
-                </select>
-            </div>""",
-            "path": """<div class="filter-group">
-                <label class="filter-label">Endpoint Path</label>
-                <input type="text" id="filter-path" class="filter-input"
-                placeholder="Search path...">
-            </div>""",
-            "app": """<div class="filter-group">
-                <label class="filter-label">Django App</label>
-                <select id="filter-app" class="filter-select">
-                    <option value="">All</option>
-                    <!-- Dynamically filled -->
-                </select>
-            </div>""",
-            "models": """<div class="filter-group">
-                <label class="filter-label">Related Models</label>
-                <input type="text" id="filter-models" class="filter-input">
-            </div>""",
-            "auth": """<div class="filter-group">
-                <label class="filter-label">Authentication Required</label>
-                <select id="filter-auth" class="filter-select">
-                    <option value="">All</option>
-                    <option value="true">Yes</option>
-                    <option value="false">No</option>
-                </select>
-            </div>""",
-            "roles": """<div class="filter-group">
-                <label class="filter-label">Permission Roles</label>
-                <input type="text" id="filter-roles" class="filter-input">
-            </div>""",
-            "content_type": """<div class="filter-group">
-                <label class="filter-label">Content Type</label>
-                <input type="text" id="filter-content-type" class="filter-input">
-            </div>""",
-            "params": """<div class="filter-group">
-                <label class="filter-label">Query Parameters</label>
-                <input type="text" id="filter-params" class="filter-input">
-            </div>""",
-            "schema": """<div class="filter-group">
-                <label class="filter-label">Schema Fields</label>
-                <input type="text" id="filter-schema" class="filter-input">
-            </div>""",
-            "pagination": """<div class="filter-group">
-                <label class="filter-label">Pagination Support</label>
-                <select id="filter-pagination" class="filter-select">
-                    <option value="">All</option>
-                    <option value="true">Yes</option>
-                    <option value="false">No</option>
-                </select>
-            </div>""",
-            "ordering": """<div class="filter-group">
-                <label class="filter-label">Ordering Support</label>
-                <select id="filter-ordering" class="filter-select">
-                    <option value="">All</option>
-                    <option value="true">Yes</option>
-                    <option value="false">No</option>
-                </select>
-            </div>""",
-            "search": """<div class="filter-group">
-                <label class="filter-label">Search Support</label>
-                <select id="filter-search" class="filter-select">
-                    <option value="">All</option>
-                    <option value="true">Yes</option>
-                    <option value="false">No</option>
-                </select>
-            </div>""",
-            "tags": """<div class="filter-group">
-                <label class="filter-label">Tags</label>
-                <input type="text" id="filter-tags" class="filter-input">
-            </div>""",
-        }
-
-        fields_html = "\n".join(
-            [html for key, html in filter_fields.items() if (key in self.active_filters)]
-        )
-
-        return f"""
-        <div class="filter-sidebar collapsed" id="filterSidebar">
-            <h3 class="filter-title">🔍 Filters</h3>
-            <div class="filter-grid">
-                {fields_html}
-            </div>
-
-            <div class="filter-actions">
-                <button class="filter-apply" onclick="applyFilters()">Apply</button>
-                <button class="filter-clear" onclick="clearFilters()">Clear</button>
-            </div>
-
-            <div class="filter-results">Showing 0 endpoints</div>
-        </div>
-        """
+        self.active_filters = active_filters or [
+            "method",
+            "path",
+            "app",
+            "models",
+            "auth",
+            "roles",
+            "content_type",
+            "params",
+            "schema",
+            "pagination",
+            "ordering",
+            "search",
+            "tags",
+        ]
 
     def create_endpoints_index(
         self, endpoints_by_app: dict[str, list[dict[str, Any]]], docs_dir: Path
     ) -> None:
+        prefix_path = f"{drf_to_mkdoc_settings.PROJECT_NAME}/"
         stylesheets = [
-            "stylesheets/endpoints/variables.css",
-            "stylesheets/endpoints/base.css",
-            "stylesheets/endpoints/theme-toggle.css",
-            "stylesheets/endpoints/filter-section.css",
-            "stylesheets/endpoints/layout.css",
-            "stylesheets/endpoints/endpoints-grid.css",
-            "stylesheets/endpoints/badges.css",
-            "stylesheets/endpoints/endpoint-content.css",
-            "stylesheets/endpoints/tags.css",
-            "stylesheets/endpoints/sections.css",
-            "stylesheets/endpoints/stats.css",
-            "stylesheets/endpoints/loading.css",
-            "stylesheets/endpoints/animations.css",
-            "stylesheets/endpoints/responsive.css",
-            "stylesheets/endpoints/accessibility.css",
-            "stylesheets/endpoints/fixes.css",
+            static(prefix_path + path)
+            for path in [
+                "stylesheets/endpoints/variables.css",
+                "stylesheets/endpoints/base.css",
+                "stylesheets/endpoints/theme-toggle.css",
+                "stylesheets/endpoints/filter-section.css",
+                "stylesheets/endpoints/layout.css",
+                "stylesheets/endpoints/endpoints-grid.css",
+                "stylesheets/endpoints/badges.css",
+                "stylesheets/endpoints/endpoint-content.css",
+                "stylesheets/endpoints/tags.css",
+                "stylesheets/endpoints/sections.css",
+                "stylesheets/endpoints/stats.css",
+                "stylesheets/endpoints/loading.css",
+                "stylesheets/endpoints/animations.css",
+                "stylesheets/endpoints/responsive.css",
+                "stylesheets/endpoints/accessibility.css",
+                "stylesheets/endpoints/fixes.css",
+            ]
         ]
 
         scripts = [
-            "javascripts/endpoints-filter.js",
+            static(prefix_path + "javascripts/endpoints-filter.js"),
         ]
-        prefix_path = f"{drf_to_mkdoc_settings.PROJECT_NAME}/"
-        css_links = "\n".join(
-            f'<link rel="stylesheet" href="{static(prefix_path + path)}">'
-            for path in stylesheets
-        )
-        js_scripts = "\n".join(
-            f'<script src="{static(prefix_path + path)}" defer></script>' for path in scripts
-        )
 
-        content = f"""# API Endpoints
-<!-- inject CSS and JS directly -->
-{css_links}
-{js_scripts}
-
-<div class="main-content">
-        """
-        content += self.create_filter_section()
+        # Process endpoints to add view_class
+        processed_endpoints = {}
+        for app_name, app_endpoints in endpoints_by_app.items():
+            processed_endpoints[app_name] = []
+            for endpoint in app_endpoints:
+                processed_endpoint = endpoint.copy()
+                processed_endpoint["view_class"] = extract_viewset_from_operation_id(
+                    endpoint["operation_id"]
+                )
+                processed_endpoint["link_url"] = (
+                    f"{app_name}/{processed_endpoint['viewset'].lower()}/{processed_endpoint['filename'].replace('.md', '/index.html')}"
+                )
+                processed_endpoints[app_name].append(processed_endpoint)
+
+        context = {
+            "stylesheets": stylesheets,
+            "scripts": scripts,
+            "endpoints_by_app": processed_endpoints,
+            "active_filters": self.active_filters,
+        }
 
-        for app_name, endpoints in endpoints_by_app.items():
-            content += f'<h2>{app_name.title()}</h2>\n<div class="endpoints-grid">\n'
-            for endpoint in endpoints:
-                viewset = endpoint["viewset"]
-                content += self.create_endpoint_card(endpoint, app_name, viewset)
-            content += "</div>\n"
+        content = render_to_string("endpoints/list/base.html", context)
 
-        content += "</div>\n"
         output_path = docs_dir / "endpoints" / "index.md"
         output_path.parent.mkdir(parents=True, exist_ok=True)
         with Path(output_path).open("w", encoding="utf-8") as f:

drf_to_mkdoc/utils/extractors/query_parameter_extractors.py

@@ -11,7 +11,6 @@ def extract_query_parameters_from_view(operation_id: str) -> dict[str, Any]:
             "search_fields": [],
             "filter_fields": [],
             "ordering_fields": [],
-            "filter_backends": [],
             "pagination_fields": [],
         }
 
@@ -19,7 +18,6 @@ def extract_query_parameters_from_view(operation_id: str) -> dict[str, Any]:
         "search_fields": extract_query_parameters_from_view_search_fields(view_class),
         "filter_fields": extract_query_parameters_from_view_filter_fields(view_class),
         "ordering_fields": extract_query_parameters_from_view_ordering_fields(view_class),
-        "filter_backends": extract_query_parameters_from_view_filter_backends(view_class),
         "pagination_fields": extract_query_parameters_from_view_pagination_fields(view_class),
     }
 
@@ -62,19 +60,6 @@ def extract_query_parameters_from_view_ordering_fields(view_class: Any) -> list[
     return ordering_fields
 
 
-def extract_query_parameters_from_view_filter_backends(view_class: Any) -> list[str]:
-    """Extract filter backends from a Django view class"""
-    if not view_class:
-        return []
-
-    filter_backends = []
-    if hasattr(view_class, "filter_backends") and view_class.filter_backends:
-        for backend in view_class.filter_backends:
-            filter_backends.append(getattr(backend, "__name__", str(backend)))
-
-    return filter_backends
-
-
 def extract_query_parameters_from_view_pagination_fields(view_class: Any) -> list[str]:
     """Extract pagination fields from a Django view class"""
     if not view_class:

drf_to_mkdoc/utils/model_detail_generator.py

@@ -1,5 +1,6 @@
 from typing import Any
 
+from django.template.loader import render_to_string
 from django.templatetags.static import static
 
 from drf_to_mkdoc.conf.settings import drf_to_mkdoc_settings
@@ -27,216 +28,35 @@ def generate_model_docs(models_data: dict[str, Any]) -> None:
             write_file(file_path, content)
 
 
-def render_column_fields_table(fields: dict[str, Any]) -> str:
-    """Render the fields table for a model."""
-    content = "## Fields\n\n"
-    content += "| Field | Type | Description | Extra |\n"
-    content += "|-------|------|-------------|-------|\n"
-
-    for field_name, field_info in fields.items():
-        field_type = field_info.get("type", "Unknown")
-        verbose_name = field_info.get("verbose_name", field_name)
-        help_text = field_info.get("help_text", "")
-
-        display_name = field_name
-        if field_type in ["ForeignKey", "OneToOneField"]:
-            display_name = f"{field_name}_id"
-
-        extra_info = []
-        if field_info.get("null"):
-            extra_info.append("null=True")
-        if field_info.get("blank"):
-            extra_info.append("blank=True")
-        if field_info.get("unique"):
-            extra_info.append("unique=True")
-        if field_info.get("primary_key"):
-            extra_info.append("primary_key=True")
-        if field_info.get("default"):
-            extra_info.append(f"default={field_info['default']}")
-
-        field_specific = field_info.get("field_specific", {})
-        for key, value in field_specific.items():
-            if key not in ["related_name", "related_query_name", "to"]:
-                extra_info.append(f"{key}={value}")
-
-        extra_str = ", ".join(extra_info) if extra_info else ""
-        description_str = help_text or verbose_name
-
-        content += f"| `{display_name}` | {field_type} | {description_str} | {extra_str} |\n"
-
-    return content
-
-
-def render_choices_tables(fields: dict[str, Any]) -> str:
-    """Render choice tables for fields with choices."""
-    choice_tables = []
-
-    for field_name, field_info in fields.items():
-        choices = field_info.get("choices")
-        if choices:
-            table = f"### {field_name} Choices\n\n"
-            table += "| Label | Value |\n"
-            table += "|-------|--------|\n"
-            for choice in choices:
-                table += f"| {choice['display']} | `{choice['value']}` |\n"
-            table += "\n"
-            choice_tables.append(table)
-
-    if choice_tables:
-        return "## Choices\n\n" + "\n".join(choice_tables)
-    return ""
-
-
 def create_model_page(model_info: dict[str, Any]) -> str:
     """Create a model documentation page from model info"""
     name = model_info.get("name", "Unknown")
     app_label = model_info.get("app_label", "unknown")
     table_name = model_info.get("table_name", "")
     description = get_model_description(name)
+    column_fields = model_info.get("column_fields", {})
 
-    content = _create_model_header(name, app_label, table_name, description)
-    content += _add_fields_section(model_info)
-    content += _add_relationships_section(model_info)
-    content += _add_methods_section(model_info)
-    content += _add_meta_options_section(model_info)
-
-    return content
-
+    # Check if any fields have choices
+    has_choices = any(field_info.get("choices") for field_info in column_fields.values())
 
-def _create_model_header(name: str, app_label: str, table_name: str, description: str) -> str:
-    """Create the header section of the model documentation."""
     stylesheets = [
-        "stylesheets/models/variables.css",
-        "stylesheets/models/base.css",
-        "stylesheets/models/model-tables.css",
-        "stylesheets/models/responsive.css",
+        static(f"{drf_to_mkdoc_settings.PROJECT_NAME}/stylesheets/models/variables.css"),
+        static(f"{drf_to_mkdoc_settings.PROJECT_NAME}/stylesheets/models/base.css"),
+        static(f"{drf_to_mkdoc_settings.PROJECT_NAME}/stylesheets/models/model-tables.css"),
+        static(f"{drf_to_mkdoc_settings.PROJECT_NAME}/stylesheets/models/responsive.css"),
     ]
-    prefix_path = f"{drf_to_mkdoc_settings.PROJECT_NAME}/"
-    css_links = "\n".join(
-        f'<link rel="stylesheet" href="{static(prefix_path + path)}">' for path in stylesheets
-    )
-    return f"""# {name}
-
-<!-- inject CSS directly -->
-{css_links}
-
-**App:** {app_label}
-**Table:** `{table_name}`
-
-## Description
-
-{description}
-
-"""
-
-
-def _add_fields_section(model_info: dict[str, Any]) -> str:
-    """Add the fields section to the model documentation."""
-    column_fields = model_info.get("column_fields", {})
-    if not column_fields:
-        return ""
-
-    content = ""
-
-    column_fields_content = render_column_fields_table(column_fields)
-    if column_fields_content:
-        content += column_fields_content
-        content += "\n"
-
-    choices_content = render_choices_tables(column_fields)
-    if choices_content:
-        content += choices_content
-        content += "\n"
-
-    return content
-
-
-def _add_relationships_section(model_info: dict[str, Any]) -> str:
-    """Add the relationships section to the model documentation."""
-    relationship_fields = model_info.get("relationships", {})
-    if not relationship_fields:
-        return ""
-
-    content = "## Relationships\n\n"
-    content += "| Field | Type | Related Model |\n"
-    content += "|-------|------|---------------|\n"
-
-    content += _render_relationship_fields(relationship_fields)
-    content += _render_relationships_from_section(relationship_fields)
-    content += "\n"
-
-    return content
-
-
-def _render_relationship_fields(relationship_fields: dict[str, Any]) -> str:
-    """Render relationship fields from the fields section."""
-    content = ""
-    for field_name, field_info in relationship_fields.items():
-        field_type = field_info.get("type", "Unknown")
-        field_specific = field_info.get("field_specific", {})
-        to_model = field_specific.get("to", "")
-
-        if to_model:
-            model_link = _create_model_link(to_model)
-            content += f"| `{field_name}` | {field_type} | {model_link}|\n"
-
-    return content
-
-
-def _render_relationships_from_section(relationships: dict[str, Any]) -> str:
-    """Render relationships from the relationships section."""
-    content = ""
-    for rel_name, rel_info in relationships.items():
-        rel_type = rel_info.get("type", "Unknown")
-
-        app_label = rel_info["app_label"]
-        table_name = rel_info["table_name"]
-        verbose_name = rel_info["verbose_name"]
-
-        model_link = f"[{verbose_name.capitalize()}](../../{app_label}/{table_name}/)"
-
-        content += f"| `{rel_name}` | {rel_type} | {model_link} | \n"
-
-    return content
-
-
-def _create_model_link(to_model: str) -> str:
-    """Create a link to a related model."""
-    if "." in to_model:
-        related_app, related_model = to_model.split(".", 1)
-        return f"[{related_model}](../{related_app}/{related_model.lower()}/)"
-    return f"[{to_model}]({to_model.lower()}/)"
-
-
-def _add_methods_section(model_info: dict[str, Any]) -> str:
-    """Add the methods section to the model documentation."""
-    methods = model_info.get("methods", [])
-    if not methods:
-        return ""
-
-    content = "## Methods\n\n"
-    for method in methods:
-        method_name = method.get("name", "")
-        docstring = method.get("docstring", "")
-
-        content += f"### `{method_name}()`\n\n"
-        if docstring:
-            content += f"{docstring}\n\n"
-        else:
-            content += "No documentation available.\n\n"
-
-    return content
-
-
-def _add_meta_options_section(model_info: dict[str, Any]) -> str:
-    """Add the meta options section to the model documentation."""
-    meta_options = model_info.get("meta_options", {})
-    if not meta_options:
-        return ""
-
-    content = "## Meta Options\n\n"
-    for option, value in meta_options.items():
-        content += f"- **{option}:** {value}\n"
-    content += "\n"
 
-    return content
+    context = {
+        "name": name,
+        "app_label": app_label,
+        "table_name": table_name,
+        "description": description,
+        "stylesheets": stylesheets,
+        "fields": column_fields,  # Changed from column_fields to fields for template consistency
+        "has_choices": has_choices,  # Added choices flag
+        "relationships": model_info.get("relationships", {}),
+        "methods": model_info.get("methods", []),
+        "meta_options": model_info.get("meta_options", {}),
+    }
+
+    return render_to_string("model_detail/base.html", context)

drf_to_mkdoc/utils/model_list_generator.py

@@ -1,8 +1,7 @@
-from html import escape
 from pathlib import Path
 from typing import Any
-from urllib.parse import quote
 
+from django.template.loader import render_to_string
 from django.templatetags.static import static
 
 from drf_to_mkdoc.conf.settings import drf_to_mkdoc_settings
@@ -12,44 +11,22 @@ from drf_to_mkdoc.utils.commons.model_utils import get_app_descriptions
 def create_models_index(models_data: dict[str, Any], docs_dir: Path) -> None:
     """Create the main models index page that lists all models organized by app."""
     stylesheets = [
-        "stylesheets/models/variables.css",
-        "stylesheets/models/base.css",
-        "stylesheets/models/model-cards.css",
-        "stylesheets/models/responsive.css",
-        "stylesheets/models/animations.css",
+        static(f"{drf_to_mkdoc_settings.PROJECT_NAME}/{path}")
+        for path in [
+            "stylesheets/models/variables.css",
+            "stylesheets/models/base.css",
+            "stylesheets/models/model-cards.css",
+            "stylesheets/models/responsive.css",
+            "stylesheets/models/animations.css",
+        ]
     ]
-    prefix_path = f"{drf_to_mkdoc_settings.PROJECT_NAME}/"
-    css_links = "\n".join(
-        f'<link rel="stylesheet" href="{static(prefix_path + path)}">' for path in stylesheets
-    )
-    content = f"""# Django Models
-
-This section contains documentation for all Django models in the system, organized by Django application.
-
-<!-- inject CSS directly -->
-{css_links}
-
-<div class="models-container">
-"""
-
-    app_descriptions = get_app_descriptions()
 
+    sorted_models = []
     for app_name, models in sorted(models_data.items()):
-        app_desc = escape(
-            app_descriptions.get(
-                app_name, f"{app_name.replace('_', ' ').title()} application models"
-            )
-        )
-        app_title = escape(app_name.replace("_", " ").title())
-        content += f'<div class="app-header">{app_title} App</div>\n'
-        content += f'<div class="app-description">{app_desc}</div>\n\n'
-
-        content += '<div class="model-cards">\n'
-
         model_names = sorted(
             [
                 (
-                    str(mi.get("verbose_name") or mk),
+                    str(mi.get("verbose_name") or mk).capitalize(),
                     str(mi.get("table_name") or mk),
                 )
                 for mk, mi in models.items()
@@ -57,18 +34,23 @@ This section contains documentation for all Django models in the system, organiz
             ],
             key=lambda x: x[0].casefold(),
         )
-        for verbose_name, table_name in model_names:
-            content += f"""
-            <a href="{quote(app_name, safe="")}/{quote(table_name, safe="")}/"
-             class="model-card">{escape(verbose_name)}</a>\n
-"""
-
-        content += "</div>\n\n"
-
-    content += """</div>
+        sorted_models.append((app_name, model_names))
 
+    app_descriptions = get_app_descriptions()
+    for app_name, _ in sorted_models:
+        if app_name not in app_descriptions:
+            app_descriptions[app_name] = (
+                f"{app_name.replace('_', ' ').title()} application models"
+            )
 
-Each model page contains detailed field documentation, method signatures, and relationships to other models."""
+    content = render_to_string(
+        "models_index.html",
+        {
+            "stylesheets": stylesheets,
+            "sorted_models": sorted_models,
+            "app_descriptions": app_descriptions,
+        },
+    )
 
     models_index_path = docs_dir / "models" / "index.md"
     models_index_path.parent.mkdir(parents=True, exist_ok=True)

drf_to_mkdoc/utils/schema.py

@@ -58,7 +58,7 @@ class ViewMetadataExtractor:
 
         try:
             serializer_cls = self.view_instance.get_serializer_class()
-        except (AttributeError, TypeError, ImportError) as e:
+        except Exception as e:
             logger.debug(f"Failed to get serializer from view instance: {e}")
             return None
         else: