The beginnings of a Django plugin.

src/python/pants/backend/python/dependency_inference/parse_python_dependencies.py

@@ -75,23 +75,31 @@ class ParserScript:
     env: FrozenDict[str, str]
 
 
-_scripts_module = "pants.backend.python.dependency_inference.scripts"
+_scripts_package = "pants.backend.python.dependency_inference.scripts"
 
 
 @rule_helper
-async def _get_script_digest(relpaths: Iterable[str]) -> Digest:
-    scripts = [read_resource(_scripts_module, relpath) for relpath in relpaths]
+async def _get_scripts_digest(scripts_package: str, filenames: Iterable[str]) -> Digest:
+    scripts = [read_resource(scripts_package, filename) for filename in filenames]
     assert all(script is not None for script in scripts)
-    path_prefix = _scripts_module.replace(".", os.path.sep)
-    digest = await Get(
-        Digest,
-        CreateDigest(
-            [
-                FileContent(os.path.join(path_prefix, relpath), script)
-                for relpath, script in zip(relpaths, scripts)
-            ]
-        ),
-    )
+    path_prefix = scripts_package.replace(".", os.path.sep)
+    contents = [
+        FileContent(os.path.join(path_prefix, relpath), script)
+        for relpath, script in zip(filenames, scripts)
+    ]
+
+    # Python 2 requires all the intermediate __init__.py to exist in the sandbox.
+    package = scripts_package
+    while package:
+        contents.append(
+            FileContent(
+                os.path.join(package.replace(".", os.path.sep), "__init__.py"),
+                read_resource(package, "__init__.py"),
+            )
+        )
+        package = package.rpartition(".")[0]
+
+    digest = await Get(Digest, CreateDigest(contents))
     return digest
 
 
@@ -102,29 +110,15 @@ async def get_parser_script(union_membership: UnionMembership) -> ParserScript:
         Get(PythonDependencyVisitor, PythonDependencyVisitorRequest, dvrt())
         for dvrt in dep_visitor_request_types
     )
-    utils = await _get_script_digest(
+    utils = await _get_scripts_digest(
+        _scripts_package,
         [
             "dependency_visitor_base.py",
             "main.py",
-        ]
+        ],
     )
 
-    # Python 2 requires all the intermediate __init__.py to exist in the sandbox.
-    init_contents = []
-    module = _scripts_module
-    while module:
-        init_contents.append(
-            FileContent(
-                os.path.join(module.replace(".", os.path.sep), "__init__.py"),
-                read_resource(module, "__init__.py"),
-            )
-        )
-        module = module.rpartition(".")[0]
-    init_scaffolding = await Get(Digest, CreateDigest(init_contents))
-
-    digest = await Get(
-        Digest, MergeDigests([utils, init_scaffolding, *(dv.digest for dv in dep_visitors)])
-    )
+    digest = await Get(Digest, MergeDigests([utils, *(dv.digest for dv in dep_visitors)]))
     env = {
         "VISITOR_CLASSNAMES": "|".join(dv.classname for dv in dep_visitors),
         "PYTHONPATH": ".",
@@ -154,10 +148,10 @@ class GeneralPythonDependencyVisitorRequest(PythonDependencyVisitorRequest):
 @rule
 async def general_parser_script(
     python_infer_subsystem: PythonInferSubsystem,
-    request: GeneralPythonDependencyVisitorRequest,
+    _: GeneralPythonDependencyVisitorRequest,
 ) -> PythonDependencyVisitor:
-    script_digest = await _get_script_digest(["general_dependency_visitor.py"])
-    classname = f"{_scripts_module}.general_dependency_visitor.GeneralDependencyVisitor"
+    script_digest = await _get_scripts_digest(_scripts_package, ["general_dependency_visitor.py"])
+    classname = f"{_scripts_package}.general_dependency_visitor.GeneralDependencyVisitor"
     return PythonDependencyVisitor(
         digest=script_digest,
         classname=classname,

src/python/pants/backend/python/dependency_inference/parse_python_dependencies_test.py

@@ -47,15 +47,17 @@ def assert_deps_parsed(
     rule_runner: RuleRunner,
     content: str,
     *,
-    expected_imports: dict[str, ImpInfo] = {},
-    expected_assets: list[str] = [],
+    expected_imports: dict[str, ImpInfo] | None = None,
+    expected_assets: list[str] | None = None,
     filename: str = "project/foo.py",
     constraints: str = ">=3.6",
     string_imports: bool = True,
     string_imports_min_dots: int = 2,
     assets: bool = True,
     assets_min_slashes: int = 1,
 ) -> None:
+    expected_imports = expected_imports or {}
+    expected_assets = expected_assets or []
     rule_runner.set_options(
         [
             f"--python-infer-string-imports={string_imports}",

src/python/pants/backend/python/framework/django/BUILD

@@ -0,0 +1,7 @@
+# Copyright 2023 Pants project contributors (see CONTRIBUTORS.md).
+# Licensed under the Apache License, Version 2.0 (see LICENSE).
+
+
+python_sources(dependencies=["src/python/pants/backend/python/framework/django/scripts"])
+
+python_tests(name="tests")

src/python/pants/backend/python/framework/django/rules.py

@@ -0,0 +1,49 @@
+# Copyright 2023 Pants project contributors (see CONTRIBUTORS.md).
+# Licensed under the Apache License, Version 2.0 (see LICENSE).
+
+from dataclasses import dataclass
+
+from pants.backend.python.dependency_inference.parse_python_dependencies import (
+    PythonDependencyVisitor,
+    PythonDependencyVisitorRequest,
+    _get_scripts_digest,
+)
+from pants.backend.python.target_types import PythonSourceField
+from pants.engine.rules import collect_rules, rule
+from pants.engine.target import FieldSet
+from pants.engine.unions import UnionRule
+from pants.util.frozendict import FrozenDict
+
+
+@dataclass(frozen=True)
+class DjangoDependencyVisitorRequest(PythonDependencyVisitorRequest):
+    pass
+
+
+_scripts_package = "pants.backend.python.framework.django.scripts"
+
+
+@rule
+async def general_parser_script(
+    _: DjangoDependencyVisitorRequest,
+) -> PythonDependencyVisitor:
+    digest = await _get_scripts_digest(_scripts_package, ["django_dependency_visitor.py"])
+    return PythonDependencyVisitor(
+        digest=digest,
+        classname=f"{_scripts_package}.django_dependency_visitor.DjangoDependencyVisitor",
+        env=FrozenDict({}),
+    )
+
+
+@dataclass(frozen=True)
+class DjangoMigrationDependenciesInferenceFieldSet(FieldSet):
+    required_fields = (PythonSourceField,)
+
+    source: PythonSourceField
+
+
+def rules():
+    return [
+        UnionRule(PythonDependencyVisitorRequest, DjangoDependencyVisitorRequest),
+        *collect_rules(),
+    ]

src/python/pants/backend/python/framework/django/rules_test.py

@@ -0,0 +1,125 @@
+# Copyright 2023 Pants project contributors (see CONTRIBUTORS.md).
+# Licensed under the Apache License, Version 2.0 (see LICENSE).
+
+from __future__ import annotations
+
+from textwrap import dedent
+
+import pytest
+
+from pants.backend.python.dependency_inference import parse_python_dependencies
+from pants.backend.python.dependency_inference.parse_python_dependencies import (
+    ParsedPythonDependencies,
+)
+from pants.backend.python.dependency_inference.parse_python_dependencies import (
+    ParsedPythonImportInfo as ImpInfo,
+)
+from pants.backend.python.dependency_inference.parse_python_dependencies import (
+    ParsePythonDependenciesRequest,
+)
+from pants.backend.python.framework.django import rules as django_rules
+from pants.backend.python.target_types import PythonSourceField, PythonSourceTarget
+from pants.backend.python.util_rules import pex
+from pants.backend.python.util_rules.interpreter_constraints import InterpreterConstraints
+from pants.core.util_rules import stripped_source_files
+from pants.engine.addresses import Address
+from pants.testutil.python_interpreter_selection import (
+    skip_unless_python27_present,
+    skip_unless_python37_present,
+    skip_unless_python38_present,
+    skip_unless_python39_present,
+)
+from pants.testutil.rule_runner import QueryRule, RuleRunner
+
+
+@pytest.fixture
+def rule_runner() -> RuleRunner:
+    return RuleRunner(
+        rules=[
+            *parse_python_dependencies.rules(),
+            *stripped_source_files.rules(),
+            *pex.rules(),
+            *django_rules.rules(),
+            QueryRule(ParsedPythonDependencies, [ParsePythonDependenciesRequest]),
+            QueryRule(ParsedPythonDependencies, [ParsePythonDependenciesRequest]),
+        ],
+        target_types=[PythonSourceTarget],
+    )
+
+
+def assert_deps_parsed(
+    rule_runner: RuleRunner,
+    content: str,
+    *,
+    expected_imports: dict[str, ImpInfo] | None = None,
+    expected_assets: list[str] | None = None,
+    filename: str = "app0/migrations/0001_initial.py",
+    constraints: str = ">=3.6",
+) -> None:
+    expected_imports = expected_imports or {}
+    expected_assets = expected_assets or []
+    rule_runner.set_options(
+        [
+            "--no-python-infer-string-imports",
+            "--no-python-infer-assets",
+        ],
+        env_inherit={"PATH", "PYENV_ROOT", "HOME"},
+    )
+    rule_runner.write_files(
+        {
+            "BUILD": f"python_source(name='t', source={repr(filename)})",
+            filename: content,
+        }
+    )
+    tgt = rule_runner.get_target(Address("", target_name="t"))
+    result = rule_runner.request(
+        ParsedPythonDependencies,
+        [
+            ParsePythonDependenciesRequest(
+                tgt[PythonSourceField],
+                InterpreterConstraints([constraints]),
+            )
+        ],
+    )
+    assert dict(result.imports) == expected_imports
+    assert list(result.assets) == sorted(expected_assets)
+
+
+def do_test_migration_dependencies(rule_runner: RuleRunner, constraints: str) -> None:
+    content = dedent(
+        """\
+        class Migration(migrations.Migration):
+            dependencies = [("app1", "0012_some_migration"), ("app2", "0042_some_other_migration")]
+
+            operations = []
+        """
+    )
+    assert_deps_parsed(
+        rule_runner,
+        content,
+        expected_imports={
+            "app1.migrations.0012_some_migration": ImpInfo(lineno=2, weak=True),
+            "app2.migrations.0042_some_other_migration": ImpInfo(lineno=2, weak=True),
+        },
+        constraints=constraints,
+    )
+
+
+@skip_unless_python27_present
+def test_works_with_python2(rule_runner: RuleRunner) -> None:
+    do_test_migration_dependencies(rule_runner, constraints="CPython==2.7.*")
+
+
+@skip_unless_python37_present
+def test_works_with_python37(rule_runner: RuleRunner) -> None:
+    do_test_migration_dependencies(rule_runner, constraints="CPython==3.7.*")
+
+
+@skip_unless_python38_present
+def test_works_with_python38(rule_runner: RuleRunner) -> None:
+    do_test_migration_dependencies(rule_runner, constraints="CPython==3.8.*")
+
+
+@skip_unless_python39_present
+def test_works_with_python39(rule_runner: RuleRunner) -> None:
+    do_test_migration_dependencies(rule_runner, constraints="CPython==3.9.*")

src/python/pants/backend/python/framework/django/scripts/BUILD

@@ -0,0 +1,4 @@
+# Copyright 2023 Pants project contributors (see CONTRIBUTORS.md).
+# Licensed under the Apache License, Version 2.0 (see LICENSE).
+
+python_sources()

src/python/pants/backend/python/framework/django/scripts/django_dependency_visitor.py

@@ -0,0 +1,48 @@
+# Copyright 2023 Pants project contributors (see CONTRIBUTORS.md).
+# Licensed under the Apache License, Version 2.0 (see LICENSE).
+# -*- coding: utf-8 -*-
+
+# NB: This must be compatible with Python 2.7 and 3.5+.
+# NB: An easy way to debug this is to invoke it directly on a file.
+#   E.g.
+#   $ PYTHONPATH=src/python VISITOR_CLASSNAMES=pants.backend.python.framework.django.scripts\
+#     .django_dependency_visitor.DjangoDependencyVisitor \
+#     python src/python/pants/backend/python/dependency_inference/scripts/main.py FILE
+
+from __future__ import print_function, unicode_literals
+
+import ast
+
+from pants.backend.python.dependency_inference.scripts.dependency_visitor_base import (
+    DependencyVisitorBase,
+)
+
+
+class DjangoDependencyVisitor(DependencyVisitorBase):
+    def __init__(self, *args, **kwargs):
+        super(DjangoDependencyVisitor, self).__init__(*args, **kwargs)
+        self._in_migration = False
+
+    def visit_ClassDef(self, node):
+        # Detect `class Migration(migrations.Migration):`
+        if (
+            node.name == "Migration"
+            and len(node.bases) > 0
+            and node.bases[0].value.id == "migrations"
+            and node.bases[0].attr == "Migration"
+        ):
+            self._in_migration = True
+        self.generic_visit(node)
+        self._in_migration = False
+
+    def visit_Assign(self, node):
+        if self._in_migration and len(node.targets) > 0 and node.targets[0].id == "dependencies":
+            if isinstance(node.value, (ast.Tuple, ast.List)):
+                for elt in node.value.elts:
+                    if isinstance(elt, (ast.Tuple, ast.List)) and len(elt.elts) == 2:
+                        app = self.maybe_str(elt.elts[0])
+                        migration = self.maybe_str(elt.elts[1])
+                        if app is not None and migration is not None:
+                            module = "{}.migrations.{}".format(app, migration)
+                            self.add_weak_import(module, node.lineno)
+        self.generic_visit(node)