drf-to-mkdoc 0.2.0__py3-none-any.whl → 0.2.2__py3-none-any.whl

drf_to_mkdoc/utils/extractors/query_parameter_extractors.py

@@ -1,8 +1,6 @@
 from typing import Any
 
-import django_filters
-
-from drf_to_mkdoc.utils.common import extract_viewset_from_operation_id
+from drf_to_mkdoc.utils.commons.operation_utils import extract_viewset_from_operation_id
 
 
 def extract_query_parameters_from_view(operation_id: str) -> dict[str, Any]:
@@ -111,35 +109,34 @@ def extract_query_parameters_from_view_pagination_fields(view_class: Any) -> lis
 
 
 def _extract_filterset_fields_from_class_attributes(filterset_class: Any) -> list[str]:
-    fields = []
-
     try:
-        # Get all class attributes, including inherited ones
-        for attr_name in dir(filterset_class):
-            # Skip private attributes and known non-filter attributes
-            if attr_name.startswith("_") or attr_name in [
-                "Meta",
-                "form",
-                "queryset",
-                "request",
-                "errors",
-                "qs",
-                "is_valid",
-            ]:
-                continue
-
-            try:
-                attr = getattr(filterset_class, attr_name)
-                if isinstance(attr, django_filters.Filter):
-                    if attr_name not in fields:
-                        fields.append(attr_name)
-            except (AttributeError, TypeError):
-                continue
-
+        import django_filters  # noqa: PLC0415
     except ImportError:
         # django_filters not available, skip this strategy
-        pass
+        return []
 
+    fields = []
+    # Get all class attributes, including inherited ones
+    for attr_name in dir(filterset_class):
+        # Skip private attributes and known non-filter attributes
+        if attr_name.startswith("_") or attr_name in [
+            "Meta",
+            "form",
+            "queryset",
+            "request",
+            "errors",
+            "qs",
+            "is_valid",
+        ]:
+            continue
+
+        try:
+            attr = getattr(filterset_class, attr_name)
+            if isinstance(attr, django_filters.Filter):
+                if attr_name not in fields:
+                    fields.append(attr_name)
+        except (AttributeError, TypeError):
+            continue
     return fields
 
 
@@ -182,7 +179,8 @@ def _extract_filterset_fields_from_internal_attrs(filterset_class: Any) -> list[
 
 
 def _extract_filterset_fields_from_get_fields(filterset_class: Any) -> list[str]:
-    if not (filterset_class._meta and filterset_class._meta.model):
+    meta = getattr(filterset_class, "_meta", None)
+    if not getattr(meta, "model", None):
         # If the Meta class is not defined in the Filter class,
         # the get_fields function is raise error
         return []
@@ -191,7 +189,12 @@ def _extract_filterset_fields_from_get_fields(filterset_class: Any) -> list[str]
     if not hasattr(filterset_class, "get_fields"):
         return []
 
-    filterset_instance = filterset_class()
+    try:
+        filterset_instance = filterset_class()
+    except TypeError:
+        # Constructor requires args; skip dynamic field discovery
+        return []
+
     filterset_fields = filterset_instance.get_fields()
     if not (filterset_fields and hasattr(filterset_fields, "keys")):
         return []

drf_to_mkdoc/utils/model_detail_generator.py

@@ -1,83 +1,31 @@
 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
-from drf_to_mkdoc.utils.common import get_model_description, write_file
+from drf_to_mkdoc.utils.commons.file_utils import write_file
+from drf_to_mkdoc.utils.commons.model_utils import get_model_description
 
 
 def generate_model_docs(models_data: dict[str, Any]) -> None:
     """Generate model documentation from JSON data"""
-    for model_name, model_info in models_data.items():
-        app_name = model_info.get("app_label", model_name.split(".")[0])
-        class_name = model_info.get("name", model_name.split(".")[-1])
+    for app_name, models in models_data.items():
+        if not isinstance(models, dict):
+            raise TypeError(f"Expected dict for models in app '{app_name}', got {type(models)}")
 
-        # Create the model page content
-        content = create_model_page(model_info)
+        for model_name, model_info in models.items():
+            if not isinstance(model_info, dict) or "name" not in model_info:
+                raise ValueError(
+                    f"Model info for '{model_name}' in app '{app_name}' is invalid"
+                )
 
-        # Write the file in app subdirectory
-        file_path = f"models/{app_name}/{class_name.lower()}.md"
-        write_file(file_path, content)
+            # Create the model page content
+            content = create_model_page(model_info)
 
-
-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 ""
+            # Write the file in app subdirectory
+            file_path = f"models/{app_name}/{model_info['table_name']}.md"
+            write_file(file_path, content)
 
 
 def create_model_page(model_info: dict[str, Any]) -> str:
@@ -86,151 +34,29 @@ def create_model_page(model_info: dict[str, Any]) -> str:
     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")
-        related_model_full = rel_info.get("related_model", "")
-
-        if related_model_full and "." in related_model_full:
-            related_app, related_model = related_model_full.split(".", 1)
-            model_link = f"[{related_model}](../../{related_app}/{related_model.lower()}/)"
-        else:
-            model_link = related_model_full
-
-        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,64 +1,56 @@
 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
-from drf_to_mkdoc.utils.common import get_app_descriptions
+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."""
-    models_by_app = {}
-    for model_name, model_info in models_data.items():
-        app_name = model_info.get("app_label", model_name.split(".")[0])
-        class_name = model_info.get("name", model_name.split(".")[-1])
-        if app_name not in models_by_app:
-            models_by_app[app_name] = []
-        models_by_app[app_name].append((class_name, model_name, model_info))
-
     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">
-"""
+    sorted_models = []
+    for app_name, models in sorted(models_data.items()):
+        model_names = sorted(
+            [
+                (
+                    str(mi.get("verbose_name") or mk).capitalize(),
+                    str(mi.get("table_name") or mk),
+                )
+                for mk, mi in models.items()
+                if isinstance(mi, dict)
+            ],
+            key=lambda x: x[0].casefold(),
+        )
+        sorted_models.append((app_name, model_names))
 
     app_descriptions = get_app_descriptions()
-
-    for app_name in sorted(models_by_app.keys()):
-        app_desc = app_descriptions.get(app_name, f"{app_name.title()} application models")
-        content += f'<div class="app-header">{app_name.title()} App</div>\n'
-        content += f'<div class="app-description">{app_desc}</div>\n\n'
-
-        content += '<div class="model-cards">\n'
-
-        for class_name, _model_name, _model_info in sorted(models_by_app[app_name]):
-            content += f"""
-            <a href="{app_name}/{class_name.lower()}/"
-             class="model-card">{class_name}</a>\n
-"""
-
-        content += "</div>\n\n"
-
-    content += """</div>
-
-
-Each model page contains detailed field documentation, method signatures, and relationships to other models."""
+    for app_name, _ in sorted_models:
+        if app_name not in app_descriptions:
+            app_descriptions[app_name] = (
+                f"{app_name.replace('_', ' ').title()} application 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)