django-orm-lens 1.2.3__tar.gz → 1.2.5__tar.gz

{django_orm_lens-1.2.3 → django_orm_lens-1.2.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: django-orm-lens
-Version: 1.2.3
+Version: 1.2.5
 Summary: Static analysis + MCP server for Django models. Sidebar tree, ER diagrams, and JSON output for terminals and AI coding agents.
 Author: frowningdev
 License: MIT

{django_orm_lens-1.2.3 → django_orm_lens-1.2.5}/django_orm_lens/parser.py

@@ -37,8 +37,17 @@ from .models import (
 
 RELATION_TYPES: Tuple[str, ...] = ("ForeignKey", "ManyToManyField", "OneToOneField")
 
-CLASS_RE = re.compile(r"^class\s+([A-Za-z_][A-Za-z0-9_]*)\s*\(([^)]*)\)\s*:")
-CLASS_START_RE = re.compile(r"^class\s+([A-Za-z_][A-Za-z0-9_]*)\s*\(")
+# ``(?:\s*\[[^\]]*\])?`` — optional PEP-695 generic type parameter list
+# introduced in Python 3.12, e.g. ``class Container[T](models.Model):``.
+# Only handles a single-line, non-nested bracket group — nested brackets in
+# class-header generics are vanishingly rare and don't warrant a full
+# bracket matcher.
+CLASS_RE = re.compile(
+    r"^class\s+([A-Za-z_][A-Za-z0-9_]*)(?:\s*\[[^\]]*\])?\s*\(([^)]*)\)\s*:"
+)
+CLASS_START_RE = re.compile(
+    r"^class\s+([A-Za-z_][A-Za-z0-9_]*)(?:\s*\[[^\]]*\])?\s*\("
+)
 
 NON_MODEL_TAIL = re.compile(
     r"^(ModelAdmin|ModelForm|ModelSerializer|ModelChoiceField|"
@@ -126,12 +135,20 @@ def _build_body_regexes(indent: int):
     # ``[^=]+`` is safe because ``=`` never appears inside a type expression
     # (subscripts, unions, dotted refs, and generics all use other punctuation).
     ann = r"(?:\s*:[^=]+)?"
+    # ``(?:[A-Za-z_][A-Za-z0-9_]*\.)?`` — optional single-identifier prefix on
+    # the RHS. Covers:
+    #   * aliased models module — ``from django.db import models as m; x = m.CharField(...)``
+    #   * third-party field packages — ``x = jsonfield.JSONField(default=dict)``
+    #   * standard bare imports — ``from django.db.models import CharField; x = CharField(...)``
+    # Safe against false positives because the type name is still restricted
+    # to Django's known field whitelist (BARE_FIELD_TYPES).
+    prefix_opt = r"(?:[A-Za-z_][A-Za-z0-9_]*\.)?"
     result = {
         "FIELD_RE": re.compile(
             rf"^{w}([a-zA-Z_][a-zA-Z0-9_]*){ann}\s*=\s*models\.([A-Za-z_][A-Za-z0-9_]*)\s*\("
         ),
         "BARE_FIELD_RE": re.compile(
-            rf"^{w}([a-zA-Z_][a-zA-Z0-9_]*){ann}\s*=\s*({BARE_FIELD_TYPES})\s*\("
+            rf"^{w}([a-zA-Z_][a-zA-Z0-9_]*){ann}\s*=\s*{prefix_opt}({BARE_FIELD_TYPES})\s*\("
         ),
         "META_START_RE": re.compile(rf"^{w}class\s+Meta\s*(?:\([^)]*\))?\s*:"),
         "META_ITEM_RE": re.compile(

{django_orm_lens-1.2.3 → django_orm_lens-1.2.5}/django_orm_lens.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: django-orm-lens
-Version: 1.2.3
+Version: 1.2.5
 Summary: Static analysis + MCP server for Django models. Sidebar tree, ER diagrams, and JSON output for terminals and AI coding agents.
 Author: frowningdev
 License: MIT

{django_orm_lens-1.2.3 → django_orm_lens-1.2.5}/django_orm_lens.egg-info/SOURCES.txt

@@ -18,6 +18,7 @@ django_orm_lens.egg-info/entry_points.txt
 django_orm_lens.egg-info/requires.txt
 django_orm_lens.egg-info/top_level.txt
 tests/test_abstract_and_auth_user.py
+tests/test_aliased_module_and_third_party_fields.py
 tests/test_cli_hint.py
 tests/test_cli_subcommands_smoke.py
 tests/test_cli_verbose.py
@@ -31,6 +32,7 @@ tests/test_migrations_parser.py
 tests/test_nplusone_detector.py
 tests/test_parity.py
 tests/test_pep526_type_hints.py
+tests/test_pep695_generic_classes.py
 tests/test_query_analyzer.py
 tests/test_scan_root.py
 tests/test_signals_parser.py

{django_orm_lens-1.2.3 → django_orm_lens-1.2.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "django-orm-lens"
-version = "1.2.3"
+version = "1.2.5"
 description = "Static analysis + MCP server for Django models. Sidebar tree, ER diagrams, and JSON output for terminals and AI coding agents."
 readme = "README.md"
 requires-python = ">=3.9"

django_orm_lens-1.2.5/tests/test_aliased_module_and_third_party_fields.py

@@ -0,0 +1,94 @@
+"""Regression tests for two field-detection gaps surfaced by targeted fuzz:
+
+1. **Aliased models module.** ``from django.db import models as m`` followed
+   by ``class X(m.Model): x = m.CharField(...)`` used to lose every field
+   because ``FIELD_RE`` hardcoded the ``models\\.`` prefix and
+   ``BARE_FIELD_RE`` had no prefix allowance at all.
+
+2. **Third-party field packages.** Fields declared via a namespaced
+   third-party import - ``x = jsonfield.JSONField(default=dict)``,
+   ``x = timezonefield.TimeZoneField()`` - also fell through the same
+   two-way gap.
+
+Fixed by adding an optional single-identifier prefix on the RHS in
+``BARE_FIELD_RE``. Safe against false positives because the type name
+is still restricted to Django's known field whitelist
+(``BARE_FIELD_TYPES``) - random ``foo.CharField(...)`` calls in
+non-Django code won't leak in unless the trailing name is a real
+Django field type.
+"""
+
+from __future__ import annotations
+
+import unittest
+
+from django_orm_lens.parser import parse_models_file
+
+
+class AliasedModelsModuleTest(unittest.TestCase):
+    def test_all_fields_captured_via_alias(self) -> None:
+        src = (
+            "from django.db import models as m\n\n"
+            "class Order(m.Model):\n"
+            "    status = m.CharField(max_length=20)\n"
+            "    total = m.DecimalField(max_digits=10, decimal_places=2)\n"
+            "    quantity = m.IntegerField(default=1)\n"
+        )
+        models = parse_models_file("shop/models.py", src)
+        self.assertEqual(len(models), 1)
+        self.assertEqual(models[0].name, "Order")
+        self.assertEqual(
+            [f.name for f in models[0].fields],
+            ["status", "total", "quantity"],
+        )
+        self.assertEqual(models[0].fields[0].type, "CharField")
+
+    def test_mixed_alias_and_plain_and_bare(self) -> None:
+        # One model, three import styles interleaved - every field must
+        # be captured regardless of prefix.
+        src = (
+            "from django.db import models as m\n"
+            "from django.db.models import IntegerField\n\n"
+            "class Row(m.Model):\n"
+            "    aliased = m.CharField(max_length=10)\n"
+            "    plain = models.TextField()\n"
+            "    bare = IntegerField(default=0)\n"
+        )
+        models = parse_models_file("t/models.py", src)
+        self.assertEqual(
+            [f.name for f in models[0].fields],
+            ["aliased", "plain", "bare"],
+        )
+
+
+class ThirdPartyFieldPackageTest(unittest.TestCase):
+    def test_jsonfield_style_package(self) -> None:
+        # `django-jsonfield`-style: `x = jsonfield.JSONField(default=dict)`.
+        # JSONField is in the standard whitelist, so this must match even
+        # under a non-`models.` prefix.
+        src = (
+            "import jsonfield\n\n"
+            "class Config(models.Model):\n"
+            "    data = jsonfield.JSONField(default=dict)\n"
+        )
+        models = parse_models_file("t/models.py", src)
+        self.assertEqual([f.name for f in models[0].fields], ["data"])
+        self.assertEqual(models[0].fields[0].type, "JSONField")
+
+    def test_plain_bare_import_still_works(self) -> None:
+        # Backward-compat: the pre-fix bare form (no prefix at all) must
+        # still match - the prefix is truly optional, not required.
+        src = (
+            "from django.db.models import CharField, IntegerField\n\n"
+            "class R(models.Model):\n"
+            "    name = CharField(max_length=50)\n"
+            "    count = IntegerField(default=0)\n"
+        )
+        models = parse_models_file("t/models.py", src)
+        self.assertEqual(
+            [f.name for f in models[0].fields], ["name", "count"]
+        )
+
+
+if __name__ == "__main__":
+    unittest.main()

django_orm_lens-1.2.5/tests/test_pep695_generic_classes.py

@@ -0,0 +1,71 @@
+"""Regression: PEP-695 generic classes (Python 3.12+) must parse.
+
+Before this fix, ``class Container[T](models.Model):`` failed the
+``CLASS_RE`` pattern entirely — the parser walked past it and reported
+zero models for the whole file. Users on Python 3.12+ writing modern
+typed Django models saw an empty sidebar/ER diagram with no error.
+
+The fix adds an optional ``(?:\\s*\\[[^\\]]*\\])?`` group between the
+class name and the opening ``(`` in both ``CLASS_RE`` and
+``CLASS_START_RE``. Covers single/multi-param, bounded, variadic, and
+paramspec generics — the four common PEP-695 shapes.
+"""
+
+from __future__ import annotations
+
+import unittest
+
+from django_orm_lens.parser import parse_models_file
+
+
+class Pep695GenericClassTest(unittest.TestCase):
+    def test_single_param_generic(self) -> None:
+        src = (
+            "class Container[T](models.Model):\n"
+            "    label = models.CharField(max_length=50)\n"
+        )
+        models = parse_models_file("t.py", src)
+        self.assertEqual(len(models), 1)
+        self.assertEqual(models[0].name, "Container")
+        self.assertEqual([f.name for f in models[0].fields], ["label"])
+
+    def test_multi_param_generic(self) -> None:
+        src = (
+            "class Pair[K, V](models.Model):\n"
+            "    key = models.CharField(max_length=10)\n"
+            "    val = models.CharField(max_length=10)\n"
+        )
+        models = parse_models_file("t.py", src)
+        self.assertEqual(len(models), 1)
+        self.assertEqual([f.name for f in models[0].fields], ["key", "val"])
+
+    def test_bounded_generic(self) -> None:
+        src = (
+            "class Bounded[T: str](models.Model):\n"
+            "    x = models.CharField(max_length=5)\n"
+        )
+        models = parse_models_file("t.py", src)
+        self.assertEqual(len(models), 1)
+
+    def test_variadic_and_paramspec(self) -> None:
+        src = (
+            "class Variadic[*Ts, **P](models.Model):\n"
+            "    x = models.CharField(max_length=5)\n"
+        )
+        models = parse_models_file("t.py", src)
+        self.assertEqual(len(models), 1)
+
+    def test_non_generic_still_works(self) -> None:
+        # Backward-compat guard — the ``[T]`` group is optional, plain
+        # class headers must still parse identically.
+        src = (
+            "class Plain(models.Model):\n"
+            "    x = models.CharField(max_length=5)\n"
+        )
+        models = parse_models_file("t.py", src)
+        self.assertEqual(len(models), 1)
+        self.assertEqual(models[0].name, "Plain")
+
+
+if __name__ == "__main__":
+    unittest.main()