Parse target version from pyproject.toml (#543)

For #322.

Author: adamchainz

CHANGELOG.rst

@@ -2,6 +2,10 @@
 Changelog
 =========
 
+* Parse target Django version from ``pyproject.toml``.
+  Now, if you don’t specify a version with ``--target-version``, django-upgrade will try to parse your minimum-supported target Django version from ``project.dependencies`` in ``pyproject.toml``.
+  It supports several common formats, like ``django>=5.2,<6.0``.
+
 * Add Django 5.2+ fixer ``postgres_aggregate_order_by`` to rewrite PostgreSQL aggregate functions using the old argument name ``ordering`` to the new name ``order_by``.
 
 * Add Django 5.2+ fixer ``staticfiles_find_all`` to rewrite calls to the staticfiles ``find()`` function using the old argument name ``all`` to the new name ``find_all``.

README.rst

@@ -52,9 +52,16 @@ Add the following to the ``repos`` section of your ``.pre-commit-config.yaml`` f
         rev: ""  # replace with latest tag on GitHub
         hooks:
         -   id: django-upgrade
-            args: [--target-version, "5.2"]   # Replace with Django version
 
-Then, upgrade your entire project:
+django-upgrade attempts to parse your current Django version from ``pyproject.toml``.
+If this doesn’t work for you, specify your target version with the ``--target-version`` option:
+
+.. code-block:: diff
+
+     -   id: django-upgrade
+    +    args: [--target-version, "5.2"]   # Replace with Django version
+
+Now, upgrade your entire project:
 
 .. code-block:: sh
 
@@ -69,15 +76,12 @@ pre-commit’s ``autoupdate`` command will also let you take advantage of future
 Usage
 =====
 
-``django-upgrade`` is a commandline tool that rewrites files in place.
-Pass your Django version as ``<major>.<minor>`` to the ``--target-version`` flag and a list of files.
-django-upgrade’s fixers will rewrite your code to avoid ``DeprecationWarning``\s and use some new features.
-
+``django-upgrade`` is a commandline tool that rewrites files in place to avoid ``DeprecationWarning``\s and use some new features.
 For example:
 
 .. code-block:: sh
 
-    django-upgrade --target-version 5.2 example/core/models.py example/settings.py
+    django-upgrade example/core/models.py example/settings.py
 
 ``django-upgrade`` focuses on upgrading your code and not on making it look nice.
 Run django-upgrade before formatters like `Black <https://black.readthedocs.io/en/stable/>`__.
@@ -120,10 +124,23 @@ Options
 
 The version of Django to target, in the format ``<major>.<minor>``.
 django-upgrade enables all of its fixers for versions up to and including the target version.
-
-This option defaults to 2.2, the oldest supported version when this project was created.
 See the list of available versions with ``django-upgrade --help``.
 
+When ``--target-version`` is not specified, django-upgrade attempts to detect the target version from a ``pyproject.toml`` in the current directory.
+If found, it attempts to parse your current minimum-supported Django version from |project.dependencies|__, supporting formats like ``django>=5.2,<6.0``.
+When available, it reports:
+
+.. |project.dependencies| replace:: ``project.dependencies``
+__ https://packaging.python.org/en/latest/specifications/pyproject-toml/#dependencies-optional-dependencies
+
+.. code-block:: sh
+
+    $ django-upgrade example.py
+    Detected Django version from pyproject.toml: 5.2
+    ...
+
+If this doesn’t work, ``--target-version`` defaults to 2.2, the oldest supported Django version when django-upgrade was created.
+
 ``--exit-zero-even-if-changed``
 -------------------------------
 

src/django_upgrade/main.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import argparse
+import re
 import sys
 import tokenize
 from collections.abc import Sequence
@@ -20,31 +21,36 @@
 from django_upgrade.data import visit
 from django_upgrade.tokens import DEDENT
 
+SUPPORTED_TARGET_VERSIONS = {
+    (1, 7),
+    (1, 8),
+    (1, 9),
+    (1, 10),
+    (1, 11),
+    (2, 0),
+    (2, 1),
+    (2, 2),
+    (3, 0),
+    (3, 1),
+    (3, 2),
+    (4, 0),
+    (4, 1),
+    (4, 2),
+    (5, 0),
+    (5, 1),
+    (5, 2),
+}
+
 
 def main(argv: Sequence[str] | None = None) -> int:
     parser = argparse.ArgumentParser(prog="django-upgrade")
     parser.add_argument("filenames", nargs="+")
     parser.add_argument(
         "--target-version",
-        default="2.2",
+        default="auto",
         choices=[
-            "1.7",
-            "1.8",
-            "1.9",
-            "1.10",
-            "1.11",
-            "2.0",
-            "2.1",
-            "2.2",
-            "3.0",
-            "3.1",
-            "3.2",
-            "4.0",
-            "4.1",
-            "4.2",
-            "5.0",
-            "5.1",
-            "5.2",
+            "auto",
+            *[f"{major}.{minor}" for major, minor in SUPPORTED_TARGET_VERSIONS],
         ],
         help="The version of Django to target.",
     )
@@ -77,13 +83,8 @@ def main(argv: Sequence[str] | None = None) -> int:
 
     args = parser.parse_args(argv)
 
-    target_version: tuple[int, int] = cast(
-        tuple[int, int],
-        tuple(int(x) for x in args.target_version.split(".", 1)),
-    )
-
     settings = Settings(
-        target_version=target_version,
+        target_version=get_target_version(args.target_version),
         only_fixers=set(args.only) if args.only else None,
         skip_fixers=set(args.skip) if args.skip else None,
     )
@@ -118,6 +119,78 @@ def __call__(
         parser.exit()
 
 
+def get_target_version(string: str) -> tuple[int, int]:
+    default = (2, 2)
+    if string != "auto":
+        return cast(
+            tuple[int, int],
+            tuple(int(x) for x in string.split(".", 1)),
+        )
+
+    if sys.version_info < (3, 11):
+        return default
+
+    import tomllib
+
+    try:
+        with open("pyproject.toml", "rb") as fp:
+            config = tomllib.load(fp)
+    except FileNotFoundError:
+        return default
+
+    deps = config.get("project", {}).get("dependencies", [])
+    for dep in deps:
+        match = re.fullmatch(
+            r"""
+            django
+            \s*
+            (
+                \[[^]]+\]
+                \s*
+            )?
+            (?:==|~=|>=)
+            \s*
+            (
+                (?P<major>[0-9]+)
+                \.
+                (?P<minor>[0-9]+)
+                (
+                    (?:a|b|rc)
+                    [0-9]+
+                |
+                    \.
+                    [0-9]+
+                |
+                )
+            )
+            (
+                \s*,\s*
+                (<|<=)
+                \s*
+                [0-9]+
+                (
+                    \.
+                    [0-9]+
+                    (
+                        \.
+                        [0-9]+
+                    )?
+                )?
+            )?
+            """,
+            dep.lower(),
+            re.VERBOSE,
+        )
+        if match:
+            major = int(match["major"])
+            minor = int(match["minor"])
+            if (major, minor) in SUPPORTED_TARGET_VERSIONS:
+                print(f"Detected Django version from pyproject.toml: {major}.{minor}")
+                return (major, minor)
+
+    return default
+
+
 def fix_file(
     filename: str,
     settings: Settings,

tests/compat.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+
+import sys
+
+if sys.version_info >= (3, 11):
+    from contextlib import chdir
+else:
+    import os
+    from contextlib import AbstractContextManager
+
+    class chdir(AbstractContextManager):
+        """Non thread-safe context manager to change the current working directory."""
+
+        def __init__(self, path):
+            self.path = path
+            self._old_cwd = []
+
+        def __enter__(self):
+            self._old_cwd.append(os.getcwd())
+            os.chdir(self.path)
+
+        def __exit__(self, *excinfo):
+            os.chdir(self._old_cwd.pop())
+
+
+__all__ = ["chdir"]

tests/test_main.py

@@ -13,8 +13,10 @@
 
 from django_upgrade import __main__  # noqa: F401
 from django_upgrade.main import fixup_dedent_tokens
+from django_upgrade.main import get_target_version
 from django_upgrade.main import main
 from django_upgrade.tokens import DEDENT
+from tests.compat import chdir
 
 
 def test_main_no_files(capsys):
@@ -128,6 +130,91 @@ def test_main_stdin_with_changes(capsys):
     assert err == ""
 
 
+@pytest.mark.parametrize(
+    "string,expected",
+    [
+        ("1.7", (1, 7)),
+        ("2.2", (2, 2)),
+        ("3.2", (3, 2)),
+        ("5.2", (5, 2)),
+    ],
+)
+def test_get_target_version_explicit(capsys, string, expected):
+    assert get_target_version(string) == expected
+    out, err = capsys.readouterr()
+    assert out == ""
+    assert err == ""
+
+
+def test_get_target_version_auto_no_pyproject_toml(tmp_path, capsys):
+    with chdir(tmp_path):
+        assert get_target_version("auto") == (2, 2)
+
+    out, err = capsys.readouterr()
+    assert out == ""
+    assert err == ""
+
+
+@pytest.mark.skipif(sys.version_info < (3, 11), reason="Python 3.11+")
+@pytest.mark.parametrize(
+    "deps_line,expected",
+    [
+        ("django>=3.2", (3, 2)),
+        ("DJANGO>=3.2", (3, 2)),
+        ("Django==4.0", (4, 0)),
+        ("django~=4.1.3", (4, 1)),
+        ("django>=3.2,<4.0", (3, 2)),
+        ("django >= 2.2, <= 3.1", (2, 2)),
+        ("django[argon2] >= 5.2", (5, 2)),
+        ("django[argon2] >= 5.2, <6", (5, 2)),
+    ],
+)
+def test_get_target_version_auto_matched(tmp_path, capsys, deps_line, expected):
+    pyproject_content = f"""[project]
+dependencies = [
+    "{deps_line}",
+]
+"""
+    (tmp_path / "pyproject.toml").write_text(pyproject_content)
+
+    with chdir(tmp_path):
+        assert get_target_version("auto") == expected
+
+    out, err = capsys.readouterr()
+    assert (
+        out
+        == f"Detected Django version from pyproject.toml: {expected[0]}.{expected[1]}\n"
+    )
+    assert err == ""
+
+
+@pytest.mark.skipif(sys.version_info < (3, 11), reason="Python 3.11+")
+@pytest.mark.parametrize(
+    "deps_line",
+    [
+        "django-upgrade>=1.0.0",
+        "Django>=5.2 ; sys_platform == 'linux'",
+        "Django>=5.2, <6.0, !=5.2.1",
+        "Django>=0.0",
+        "DJANGO[argon2]>=0.0",
+    ],
+)
+def test_get_target_version_auto_unmatched(tmp_path, capsys, deps_line):
+    pyproject_content = f"""[project]
+dependencies = [
+    "{deps_line}",
+]
+"""
+    (tmp_path / "pyproject.toml").write_text(pyproject_content)
+
+    with chdir(tmp_path):
+        assert get_target_version("auto") == (2, 2)
+
+    out, err = capsys.readouterr()
+    assert out == ""
+    assert err == ""
+
+
 def test_fixup_dedent_tokens():
     code = dedent(
         """\