django-schematic 0.3.6__tar.gz

django_schematic-0.3.6/.gitignore

@@ -0,0 +1,51 @@
+# Python
+__pycache__/
+*.py[cod]
+*.pyo
+*.pyd
+.Python
+*.egg
+*.egg-info/
+dist/
+build/
+.eggs/
+.venv/
+venv/
+env/
+.env
+.claude
+
+# Hatch
+.hatch/
+
+# Django
+*.sqlite3
+local_settings.py
+db.sqlite3
+
+# Frontend
+ui/node_modules/
+ui/dist/
+ui/.vite/
+
+# Static files (keep the committed build artifact)
+# schematic/static/schematic/main.js is committed intentionally
+
+# Testing
+.pytest_cache/
+.coverage
+htmlcov/
+.tox/
+
+# mypy
+.mypy_cache/
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+.DS_Store
+
+# Logs
+*.log

django_schematic-0.3.6/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 jsheffie
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

django_schematic-0.3.6/PKG-INFO

@@ -0,0 +1,142 @@
+Metadata-Version: 2.4
+Name: django-schematic
+Version: 0.3.6
+Summary: Interactive schema visualization for Django projects — React Flow + force-directed layout
+Project-URL: Homepage, https://github.com/jsheffie/django-schematic
+Project-URL: Repository, https://github.com/jsheffie/django-schematic
+Project-URL: Issues, https://github.com/jsheffie/django-schematic/issues
+License: MIT License
+        
+        Copyright (c) 2026 jsheffie
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+License-File: LICENSE
+Keywords: django,graph,models,schema,visualization
+Classifier: Development Status :: 3 - Alpha
+Classifier: Framework :: Django
+Classifier: Framework :: Django :: 5.1
+Classifier: Framework :: Django :: 5.2
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.12
+Requires-Dist: django>=5.1
+Provides-Extra: dev
+Requires-Dist: django-stubs; extra == 'dev'
+Requires-Dist: mypy; extra == 'dev'
+Requires-Dist: pytest; extra == 'dev'
+Requires-Dist: pytest-django; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# django-schematic
+
+Interactive schema visualization for Django projects.
+
+See all your models, fields, and relationships as an interactive, force-directed graph — directly in your browser. Zero Node.js required at runtime.
+
+## Features
+
+- Force-directed layout with physics settle animation (drag-to-pin support)
+- Hierarchical layout via dagre
+- Click to expand/collapse field lists per model
+- App-based color coding
+- Show/hide models and apps via sidebar
+- Export/import view state as JSON
+- Export diagram as PNG
+- Clean JSON API endpoint (`GET /schema/api/`)
+- Django 5.x + Python 3.12+ only
+
+## Screenshots
+
+<img width="1712" height="943" alt="Screenshot 2026-04-12 at 11 13 05 PM" src="https://github.com/user-attachments/assets/7048a332-fec1-420f-b331-52b6da2eb5ef" />
+<img width="1337" height="928" alt="Screenshot 2026-04-12 at 11 13 46 PM" src="https://github.com/user-attachments/assets/5f8776c2-e62c-4154-8a49-c77282d4857e" />
+<img width="996" height="865" alt="Screenshot 2026-04-12 at 11 15 06 PM" src="https://github.com/user-attachments/assets/9feb182b-921d-4765-88eb-cf0a5f845400" />
+
+
+## Quick Start
+
+```bash
+pip install django-schematic
+```
+
+Add to `INSTALLED_APPS`:
+
+```python
+INSTALLED_APPS = [
+    ...
+    "schematic",
+]
+```
+
+Add to `urls.py` (behind a staff-only guard in production):
+
+```python
+from django.urls import include, path
+
+urlpatterns = [
+    ...
+    path("schema/", include("schematic.urls")),
+]
+```
+
+Visit `http://localhost:8000/schema/` — your model graph will be there.
+
+## Configuration
+
+```python
+# settings.py (all optional — these are the defaults)
+SCHEMATIC = {
+    "visible": True,              # or callable(request) -> bool
+    "include_apps": [],           # empty = all apps
+    "exclude_apps": ["admin", "contenttypes", "sessions", "auth"],
+    "exclude_models": {},         # {"myapp": ["InternalModel"]}
+    "include_abstract": False,
+    "include_proxy": True,
+}
+```
+
+## API
+
+The schema is also available as JSON:
+
+```
+GET /schema/api/
+GET /schema/api/?apps=myapp,otherapp
+```
+
+## Development
+
+```bash
+# Backend
+pip install -e ".[dev]"
+pytest
+
+# Frontend
+cd ui
+npm install
+npm run dev   # Vite dev server with HMR
+npm run build # Outputs to schematic/static/schematic/
+```
+
+## License
+
+MIT

django_schematic-0.3.6/README.md

@@ -0,0 +1,93 @@
+# django-schematic
+
+Interactive schema visualization for Django projects.
+
+See all your models, fields, and relationships as an interactive, force-directed graph — directly in your browser. Zero Node.js required at runtime.
+
+## Features
+
+- Force-directed layout with physics settle animation (drag-to-pin support)
+- Hierarchical layout via dagre
+- Click to expand/collapse field lists per model
+- App-based color coding
+- Show/hide models and apps via sidebar
+- Export/import view state as JSON
+- Export diagram as PNG
+- Clean JSON API endpoint (`GET /schema/api/`)
+- Django 5.x + Python 3.12+ only
+
+## Screenshots
+
+<img width="1712" height="943" alt="Screenshot 2026-04-12 at 11 13 05 PM" src="https://github.com/user-attachments/assets/7048a332-fec1-420f-b331-52b6da2eb5ef" />
+<img width="1337" height="928" alt="Screenshot 2026-04-12 at 11 13 46 PM" src="https://github.com/user-attachments/assets/5f8776c2-e62c-4154-8a49-c77282d4857e" />
+<img width="996" height="865" alt="Screenshot 2026-04-12 at 11 15 06 PM" src="https://github.com/user-attachments/assets/9feb182b-921d-4765-88eb-cf0a5f845400" />
+
+
+## Quick Start
+
+```bash
+pip install django-schematic
+```
+
+Add to `INSTALLED_APPS`:
+
+```python
+INSTALLED_APPS = [
+    ...
+    "schematic",
+]
+```
+
+Add to `urls.py` (behind a staff-only guard in production):
+
+```python
+from django.urls import include, path
+
+urlpatterns = [
+    ...
+    path("schema/", include("schematic.urls")),
+]
+```
+
+Visit `http://localhost:8000/schema/` — your model graph will be there.
+
+## Configuration
+
+```python
+# settings.py (all optional — these are the defaults)
+SCHEMATIC = {
+    "visible": True,              # or callable(request) -> bool
+    "include_apps": [],           # empty = all apps
+    "exclude_apps": ["admin", "contenttypes", "sessions", "auth"],
+    "exclude_models": {},         # {"myapp": ["InternalModel"]}
+    "include_abstract": False,
+    "include_proxy": True,
+}
+```
+
+## API
+
+The schema is also available as JSON:
+
+```
+GET /schema/api/
+GET /schema/api/?apps=myapp,otherapp
+```
+
+## Development
+
+```bash
+# Backend
+pip install -e ".[dev]"
+pytest
+
+# Frontend
+cd ui
+npm install
+npm run dev   # Vite dev server with HMR
+npm run build # Outputs to schematic/static/schematic/
+```
+
+## License
+
+MIT

django_schematic-0.3.6/pyproject.toml

@@ -0,0 +1,63 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "django-schematic"
+version = "0.3.6"
+description = "Interactive schema visualization for Django projects — React Flow + force-directed layout"
+readme = "README.md"
+license = { file = "LICENSE" }
+requires-python = ">=3.12"
+dependencies = [
+    "django>=5.1",
+]
+keywords = ["django", "schema", "visualization", "graph", "models"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Framework :: Django",
+    "Framework :: Django :: 5.1",
+    "Framework :: Django :: 5.2",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest",
+    "pytest-django",
+    "mypy",
+    "django-stubs",
+]
+
+[project.urls]
+Homepage = "https://github.com/jsheffie/django-schematic"
+Repository = "https://github.com/jsheffie/django-schematic"
+Issues = "https://github.com/jsheffie/django-schematic/issues"
+
+[tool.hatch.build.targets.wheel]
+packages = ["schematic"]
+
+[tool.hatch.build.targets.sdist]
+include = [
+    "schematic/",
+    "LICENSE",
+    "README.md",
+    "pyproject.toml",
+]
+
+[tool.pytest.ini_options]
+DJANGO_SETTINGS_MODULE = "tests.settings"
+pythonpath = ["."]
+
+[tool.mypy]
+python_version = "3.12"
+strict = true
+plugins = ["mypy_django_plugin.main"]
+
+[tool.django-stubs]
+django_settings_module = "tests.settings"

django_schematic-0.3.6/schematic/apps.py

@@ -0,0 +1,7 @@
+from django.apps import AppConfig
+
+
+class SchemaGraphConfig(AppConfig):
+    name = "schematic"
+    verbose_name = "Django Schematic"
+    default_auto_field = "django.db.models.BigAutoField"

django_schematic-0.3.6/schematic/schema.py

@@ -0,0 +1,217 @@
+"""
+Schema extraction — walks Django's app registry and model._meta API to build
+a serializable graph of nodes (models) and edges (relationships).
+"""
+from __future__ import annotations
+
+import dataclasses
+import json
+from typing import TYPE_CHECKING
+
+from django.apps import apps as django_apps
+
+from .settings import get_setting
+
+if TYPE_CHECKING:
+    from django.db import models as django_models
+
+
+# ---------------------------------------------------------------------------
+# Data model
+# ---------------------------------------------------------------------------
+
+
+@dataclasses.dataclass(frozen=True, order=True)
+class FieldInfo:
+    name: str
+    field_type: str
+    is_relation: bool
+    null: bool
+    unique: bool
+
+
+@dataclasses.dataclass(frozen=True, order=True)
+class NodeInfo:
+    id: str          # e.g. "myapp.Order"
+    name: str        # e.g. "Order"
+    app_label: str   # e.g. "myapp"
+    tags: tuple[str, ...]   # "abstract", "proxy"
+    fields: tuple[FieldInfo, ...]
+
+
+@dataclasses.dataclass(frozen=True, order=True)
+class EdgeInfo:
+    source: str       # NodeInfo.id
+    target: str       # NodeInfo.id
+    relation_type: str  # "fk" | "o2o" | "m2m" | "subclass" | "proxy"
+    field_name: str
+    related_name: str | None
+
+
+@dataclasses.dataclass(frozen=True)
+class SchemaGraph:
+    nodes: tuple[NodeInfo, ...]
+    edges: tuple[EdgeInfo, ...]
+    app_labels: tuple[str, ...]
+
+    def to_dict(self) -> dict:
+        return dataclasses.asdict(self)
+
+    def to_json(self) -> str:
+        return json.dumps(self.to_dict())
+
+
+# ---------------------------------------------------------------------------
+# Extraction
+# ---------------------------------------------------------------------------
+
+
+def _node_id(model: type[django_models.Model]) -> str:
+    return f"{model._meta.app_label}.{model.__name__}"
+
+
+def _extract_fields(model: type[django_models.Model]) -> tuple[FieldInfo, ...]:
+    fields = []
+    for f in model._meta.get_fields():
+        if not hasattr(f, "column"):
+            # Reverse relations — skip; they appear as edges from the other side
+            continue
+        fields.append(
+            FieldInfo(
+                name=f.name,
+                field_type=type(f).__name__,
+                is_relation=f.is_relation if hasattr(f, "is_relation") else False,
+                null=getattr(f, "null", False),
+                unique=getattr(f, "unique", False),
+            )
+        )
+    return tuple(sorted(fields))
+
+
+def _tags(model: type[django_models.Model]) -> tuple[str, ...]:
+    tags = []
+    if model._meta.abstract:
+        tags.append("abstract")
+    if model._meta.proxy:
+        tags.append("proxy")
+    return tuple(tags)
+
+
+def _extract_edges(
+    model: type[django_models.Model],
+    all_model_ids: set[str],
+) -> list[EdgeInfo]:
+    edges: list[EdgeInfo] = []
+    source = _node_id(model)
+
+    for f in model._meta.get_fields():
+        if not getattr(f, "is_relation", False):
+            continue
+        if not hasattr(f, "related_model") or f.related_model is None:
+            continue
+        target = _node_id(f.related_model)
+        if target not in all_model_ids:
+            continue
+
+        # Skip reverse accessors — process each relationship once from the owning side
+        if hasattr(f, "field") and not hasattr(f, "column"):
+            continue
+
+        from django.db.models import ForeignKey, ManyToManyField, OneToOneField
+
+        if isinstance(f, OneToOneField):
+            rel = "o2o"
+        elif isinstance(f, ForeignKey):
+            rel = "fk"
+        elif isinstance(f, ManyToManyField):
+            rel = "m2m"
+        else:
+            rel = "fk"
+
+        edges.append(
+            EdgeInfo(
+                source=source,
+                target=target,
+                relation_type=rel,
+                field_name=f.name,
+                related_name=getattr(f, "related_query_name", lambda: None)() or None,
+            )
+        )
+
+    # Subclass edges (multi-table inheritance and proxy)
+    for parent in model.__bases__:
+        if not hasattr(parent, "_meta"):
+            continue
+        parent_id = _node_id(parent)  # type: ignore[arg-type]
+        if parent_id not in all_model_ids:
+            continue
+        rel = "proxy" if model._meta.proxy else "subclass"
+        edges.append(
+            EdgeInfo(
+                source=source,
+                target=parent_id,
+                relation_type=rel,
+                field_name="",
+                related_name=None,
+            )
+        )
+
+    return edges
+
+
+def build_schema(filter_apps: list[str] | None = None) -> SchemaGraph:
+    """
+    Walk the Django app registry and return a SchemaGraph.
+
+    filter_apps: if provided, only include models from these app labels.
+    """
+    exclude_apps: list[str] = get_setting("exclude_apps")
+    exclude_models: dict[str, list[str]] = get_setting("exclude_models")
+    include_abstract: bool = get_setting("include_abstract")
+    include_proxy: bool = get_setting("include_proxy")
+    include_apps: list[str] = get_setting("include_apps")
+
+    # Determine which apps to include
+    all_app_configs = django_apps.get_app_configs()
+    app_configs = [
+        ac for ac in all_app_configs
+        if ac.label not in exclude_apps
+        and (not include_apps or ac.label in include_apps)
+        and (not filter_apps or ac.label in filter_apps)
+    ]
+
+    # Collect all models
+    all_models: list[type[django_models.Model]] = []
+    for ac in app_configs:
+        for model in ac.get_models():
+            if model._meta.abstract and not include_abstract:
+                continue
+            if model._meta.proxy and not include_proxy:
+                continue
+            excluded = exclude_models.get(ac.label, [])
+            if model.__name__ in excluded:
+                continue
+            all_models.append(model)
+
+    all_model_ids = {_node_id(m) for m in all_models}
+
+    nodes = tuple(
+        sorted(
+            NodeInfo(
+                id=_node_id(m),
+                name=m.__name__,
+                app_label=m._meta.app_label,
+                tags=_tags(m),
+                fields=_extract_fields(m),
+            )
+            for m in all_models
+        )
+    )
+
+    edges: list[EdgeInfo] = []
+    for m in all_models:
+        edges.extend(_extract_edges(m, all_model_ids))
+
+    app_labels = tuple(sorted({n.app_label for n in nodes}))
+
+    return SchemaGraph(nodes=nodes, edges=tuple(edges), app_labels=app_labels)

django_schematic-0.3.6/schematic/settings.py

@@ -0,0 +1,15 @@
+from django.conf import settings
+
+DEFAULTS: dict = {
+    "visible": True,
+    "include_apps": [],
+    "exclude_apps": ["admin", "contenttypes", "sessions", "auth"],
+    "exclude_models": {},
+    "include_abstract": False,
+    "include_proxy": True,
+}
+
+
+def get_setting(key: str):
+    user_settings: dict = getattr(settings, "SCHEMATIC", {})
+    return user_settings.get(key, DEFAULTS[key])