openrewrite-migrate-python 0.17.0.dev20261021175539__tar.gz → 0.17.0.dev20261022150922__tar.gz

{openrewrite_migrate_python-0.17.0.dev20261021175539 → openrewrite_migrate_python-0.17.0.dev20261022150922}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openrewrite-migrate-python
-Version: 0.17.0.dev20261021175539
+Version: 0.17.0.dev20261022150922
 Summary: OpenRewrite recipes for migrating Python codebases to newer Python versions.
 Author-email: "Moderne Inc." <support@moderne.io>
 License: Moderne Proprietary

{openrewrite_migrate_python-0.17.0.dev20261021175539 → openrewrite_migrate_python-0.17.0.dev20261022150922}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "setuptools.build_meta"
 [project]
 name = "openrewrite-migrate-python"
 description = "OpenRewrite recipes for migrating Python codebases to newer Python versions."
-version = "0.17.0.dev20261021175539"  # Updated dynamically during release
+version = "0.17.0.dev20261022150922"  # Updated dynamically during release
 authors = [{ name = "Moderne Inc.", email = "support@moderne.io" }]
 license = { text = "Moderne Proprietary" }
 readme = "README.md"

openrewrite_migrate_python-0.17.0.dev20261022150922/src/openrewrite_migrate_python/migrate/cgi_escape_deprecations.py

@@ -0,0 +1,186 @@
+"""
+Recipe for replacing the removed cgi.escape() with html.escape().
+
+cgi.escape() was deprecated in Python 3.2 and removed in Python 3.8. Its
+replacement html.escape() escapes quotes by default, where cgi.escape() did
+not, so a call that relied on the default passes quote=False. A reference the
+recipe cannot carry the default over for is marked instead.
+
+See: https://docs.python.org/3/whatsnew/3.8.html#api-and-feature-removals
+"""
+
+from typing import Any, List, Set
+
+from rewrite import Cursor, ExecutionContext, Preconditions, Recipe, TreeVisitor
+from rewrite.category import CategoryDescriptor
+from rewrite.decorators import categorize
+from rewrite.marketplace import Python
+from rewrite.python.binding import maybe_rebind
+from rewrite.python.binding_utils import import_bindings
+from rewrite.python.method_matcher import MethodMatcher
+from rewrite.python.preconditions import uses_method
+from rewrite.python.template import template
+from rewrite.python.tree import CompilationUnit, ExpressionStatement, NamedArgument, Star
+from rewrite.python.visitor import PythonVisitor
+from rewrite.java.support_types import JRightPadded, Space
+from rewrite.java.tree import FieldAccess, Identifier, J, MethodInvocation
+
+from ._markers import mark_deprecated
+
+# Define category path: Python > Migrate > Python 3.8
+_Python38 = [
+    *Python,
+    CategoryDescriptor(display_name="Migrate"),
+    CategoryDescriptor(display_name="Python 3.8"),
+]
+
+_ESCAPE_PATTERN = "cgi escape(..)"
+_ESCAPE = MethodMatcher.create(_ESCAPE_PATTERN)
+_QUOTE_FALSE = template("escape(s, quote=False)")
+_MANUAL = (
+    "`cgi.escape()` was removed in Python 3.8. Replace it with `html.escape()`, "
+    "passing `quote=False` unless quotes should now be escaped too"
+)
+
+
+@categorize(_Python38)
+class ReplaceCgiEscape(Recipe):
+    """
+    Replace ``cgi.escape()`` with ``html.escape()``, keeping quotes unescaped.
+
+    ``cgi.escape(s)`` left quotes alone unless called with ``quote=True``, while
+    ``html.escape(s)`` escapes them by default. A call without a ``quote``
+    argument therefore gains ``quote=False``.
+
+    Example:
+        Before:
+            import cgi
+            safe = cgi.escape(text)
+            attr = cgi.escape(text, True)
+
+        After:
+            import html
+            safe = html.escape(text, quote=False)
+            attr = html.escape(text, True)
+    """
+
+    @property
+    def name(self) -> str:
+        return "org.openrewrite.python.migrate.ReplaceCgiEscape"
+
+    @property
+    def display_name(self) -> str:
+        return "Replace `cgi.escape()` with `html.escape()`"
+
+    @property
+    def description(self) -> str:
+        return (
+            "`cgi.escape()` was removed in Python 3.8. Replace it with `html.escape()`, "
+            "passing `quote=False` where the call gave no `quote` argument, since "
+            "`html.escape()` escapes quotes by default and `cgi.escape()` did not. An explicit "
+            "`quote` argument is kept as it is. A file that also refers to `cgi.escape` other than "
+            "by calling it, or calls it with unpacked `*args` or `**kwargs`, is left as it is, with "
+            "those references marked for a manual change. A file that never calls it is not visited."
+        )
+
+    @property
+    def tags(self) -> List[str]:
+        return ["python", "migration", "3.8", "cgi"]
+
+    def editor(self) -> TreeVisitor[Any, ExecutionContext]:
+        class Visitor(PythonVisitor[ExecutionContext]):
+            unsafe: Set[Any] = set()
+
+            def visit_compilation_unit(self, cu: CompilationUnit, p: ExecutionContext) -> J:
+                finder = _EscapeReferences()
+                finder.visit(cu, p)
+                self.unsafe = finder.unsafe
+                visited = super().visit_compilation_unit(cu, p)
+                if finder.found and not finder.unsafe:
+                    maybe_rebind(self, "cgi", "html", from_member="escape")
+                return visited
+
+            def visit_method_invocation(self, method: MethodInvocation, p: ExecutionContext) -> J:
+                m = super().visit_method_invocation(method, p)
+                if not isinstance(m, MethodInvocation):
+                    return m
+                if self.unsafe:
+                    return mark_deprecated(m, _MANUAL) if m.id in self.unsafe else m
+                if not _ESCAPE.matches(m, cursor=self.cursor) or not _relies_on_default_quote(m):
+                    return m
+                quote = _quote_false(self.cursor)
+                if quote is None:
+                    return m
+                arguments = m.padding.arguments
+                last = arguments.padding.elements[-1]
+                elements = [
+                    last.replace(_after=Space.EMPTY, _markers=quote.markers),
+                    quote.replace(_after=last.after, _markers=last.markers),
+                ]
+                return m.padding.replace(_arguments=arguments.padding.replace(elements=elements))
+
+            def visit_field_access(self, field_access: FieldAccess, p: ExecutionContext) -> J:
+                fa = super().visit_field_access(field_access, p)
+                return mark_deprecated(fa, _MANUAL) if fa.id in self.unsafe else fa
+
+            def visit_identifier(self, ident: Identifier, p: ExecutionContext) -> J:
+                i = super().visit_identifier(ident, p)
+                return mark_deprecated(i, _MANUAL) if i.id in self.unsafe else i
+
+        return Preconditions.check(uses_method(_ESCAPE_PATTERN), Visitor())
+
+
+class _EscapeReferences(PythonVisitor[ExecutionContext]):
+    """Finds the file's references to ``cgi.escape``, and those whose meaning the move would change."""
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.found = False
+        self.unsafe: Set[Any] = set()
+
+    def visit_method_invocation(self, method: MethodInvocation, p: ExecutionContext) -> J:
+        if _ESCAPE.matches(method, cursor=self.cursor):
+            self.found = True
+            if not method.arguments or any(isinstance(arg, Star) for arg in method.arguments):
+                self.unsafe.add(method.id)
+        return super().visit_method_invocation(method, p)
+
+    def visit_field_access(self, field_access: FieldAccess, p: ExecutionContext) -> J:
+        # A call is a MethodInvocation, so `cgi.escape` as a FieldAccess is passed around, not called.
+        target = field_access.target
+        if field_access.name.simple_name == "escape" and isinstance(target, Identifier):
+            binding = import_bindings(self).reference(Cursor(self.cursor, target), target)
+            if binding is not None and binding.module == "cgi" and binding.member is None:
+                self.found = True
+                self.unsafe.add(field_access.id)
+        return super().visit_field_access(field_access, p)
+
+    def visit_identifier(self, ident: Identifier, p: ExecutionContext) -> J:
+        binding = import_bindings(self).reference(self.cursor, ident)
+        if binding is not None and binding.module == "cgi" and binding.member == "escape":
+            parent = self.cursor.parent_tree_cursor().value
+            if not (isinstance(parent, MethodInvocation) and parent.name is ident):
+                self.found = True
+                self.unsafe.add(ident.id)
+        return super().visit_identifier(ident, p)
+
+
+def _relies_on_default_quote(call: MethodInvocation) -> bool:
+    """Whether ``call`` passes only the string, by position or as ``s=``."""
+    if len(call.arguments) != 1:
+        return False
+    only = call.arguments[0]
+    if isinstance(only, NamedArgument):
+        return only.name.simple_name == "s"
+    return not isinstance(only, Star)
+
+
+def _quote_false(cursor: Cursor) -> JRightPadded | None:
+    """A ``quote=False`` argument as a parse gives it, padded to follow a comma."""
+    call = _QUOTE_FALSE.apply(cursor, format=False)
+    if isinstance(call, ExpressionStatement):
+        call = call.expression
+    if not isinstance(call, MethodInvocation):
+        return None
+    quote = call.padding.arguments.padding.elements[-1]
+    return quote.replace(_element=quote.element.replace(prefix=Space.SINGLE_SPACE))

{openrewrite_migrate_python-0.17.0.dev20261021175539 → openrewrite_migrate_python-0.17.0.dev20261022150922}/src/openrewrite_migrate_python/migrate/cgi_parse_deprecations.py

@@ -6,7 +6,7 @@ The following functions were deprecated in Python 3.2 and removed in Python 3.8:
 - cgi.parse_qs() -> urllib.parse.parse_qs()
 - cgi.parse_qsl() -> urllib.parse.parse_qsl()
 
-Note: cgi.escape() -> html.escape() is handled in cgi_migrations.py.
+Note: cgi.escape() -> html.escape() is handled in cgi_escape_deprecations.py.
 
 See: https://docs.python.org/3/whatsnew/3.8.html#api-and-feature-removals
 """

{openrewrite_migrate_python-0.17.0.dev20261021175539 → openrewrite_migrate_python-0.17.0.dev20261022150922}/src/openrewrite_migrate_python/migrate/string_formatting.py

@@ -35,6 +35,7 @@ from rewrite.utils import random_id
 
 from openrewrite_code_quality_python.cleanup._literals import is_string_literal
 from openrewrite_code_quality_python.codequality._side_effects import is_side_effect_free
+from openrewrite_code_quality_python.codequality._trivia import has_comments
 
 from ._slots import as_slot_of
 
@@ -173,6 +174,10 @@ def _convert_format_to_fstring(method: MethodInvocation) -> FormattedString | No
     if not isinstance(select, Literal):
         return None
 
+    # The f-string is rebuilt from the parts, which drops every comment inside the call
+    if has_comments(method.replace(prefix=Space.EMPTY)):
+        return None
+
     value_source = select.value_source
     if not value_source:
         return None
@@ -366,7 +371,7 @@ class ReplaceStrFormatWithFString(Recipe):
             "conversion is safe. A format string with a backslash escape, a raw or bytes prefix, "
             "or a field reading an attribute or index is left alone. So is a call with an unpacked "
             "argument, a string literal argument, or an argument that has side effects and is "
-            "used more than once."
+            "used more than once, and a call with a comment inside it, which the f-string would drop."
         )
 
     @property
@@ -449,6 +454,10 @@ def _convert_percent_to_fstring(binary: Binary) -> FormattedString | None:
     if not isinstance(left, Literal):
         return None
 
+    # The f-string is rebuilt from the parts, which drops every comment inside the expression
+    if has_comments(binary.replace(prefix=Space.EMPTY)):
+        return None
+
     value_source = left.value_source
     if not value_source:
         return None
@@ -581,7 +590,8 @@ class ReplacePercentFormatWithFString(Recipe):
             "Only converts `%s` and `%r` specifiers where the format string is "
             "a literal and the conversion is safe. A single operand that is not a "
             "tuple literal must have a type that resolves to a non-tuple, such as "
-            "`str` or `int`, since a tuple would be spread over the specifiers."
+            "`str` or `int`, since a tuple would be spread over the specifiers. "
+            "An expression with a comment inside it is left alone, since the f-string would drop it."
         )
 
     @property

openrewrite_migrate_python-0.17.0.dev20261022150922/src/openrewrite_migrate_python/migrate/sys_last_deprecations.py

@@ -0,0 +1,227 @@
+"""
+Recipe for replacing deprecated sys.last_type/last_value/last_traceback
+with sys.last_exc equivalents.
+
+sys.last_type, sys.last_value, and sys.last_traceback were deprecated in
+Python 3.12 in favor of sys.last_exc:
+
+- sys.last_value     -> sys.last_exc
+- sys.last_type      -> type(sys.last_exc)
+- sys.last_traceback -> sys.last_exc.__traceback__
+
+See: https://docs.python.org/3/whatsnew/3.12.html#deprecated
+"""
+
+from typing import Any, List
+
+from rewrite import Cursor, ExecutionContext, Preconditions, Recipe, TreeVisitor
+from rewrite.category import CategoryDescriptor
+from rewrite.decorators import categorize
+from rewrite.marketplace import Python
+from rewrite.python.binding_utils import import_bindings
+from rewrite.python.method_matcher import MethodMatcher
+from rewrite.python.preconditions import uses_import
+from rewrite.python.remove_import import RemoveImportOptions, maybe_remove_import
+from rewrite.python.scope_utils import scope_of
+from rewrite.python.template import template
+from rewrite.python.visitor import PythonVisitor
+from rewrite.python.tree import (
+    ChainedAssignment,
+    CollectionLiteral,
+    CompilationUnit,
+    ComprehensionExpression,
+    Del,
+    ExpressionStatement,
+    Star,
+    TypeHintedExpression,
+)
+from rewrite.java.tree import (
+    Assignment,
+    AssignmentOperation,
+    FieldAccess,
+    ForEachLoop,
+    Identifier,
+    J,
+    Literal,
+    MethodInvocation,
+    Parentheses,
+)
+
+# Define category path: Python > Migrate > Python 3.12
+_Python312 = [
+    *Python,
+    CategoryDescriptor(display_name="Migrate"),
+    CategoryDescriptor(display_name="Python 3.12"),
+]
+
+_REPLACEMENTS = {
+    attribute: template(replacement, context=["import sys"])
+    for attribute, replacement in (
+        ("last_value", "sys.last_exc"),
+        ("last_type", "type(sys.last_exc)"),
+        ("last_traceback", "sys.last_exc.__traceback__"),
+    )
+}
+
+_HASATTR = MethodMatcher.create("builtins hasattr(..)")
+
+
+@categorize(_Python312)
+class ReplaceSysLastExcInfo(Recipe):
+    """
+    Replace ``sys.last_type``, ``sys.last_value``, and ``sys.last_traceback`` with
+    their ``sys.last_exc``-based equivalents.
+
+    These attributes were deprecated in Python 3.12 in favor of ``sys.last_exc``
+    which provides the exception object directly.
+
+    Example:
+        Before:
+            import sys
+            if hasattr(sys, "last_type"):
+                exc_type = sys.last_type
+                exc_value = sys.last_value
+                exc_tb = sys.last_traceback
+
+        After:
+            import sys
+            if hasattr(sys, "last_exc"):
+                exc_type = type(sys.last_exc)
+                exc_value = sys.last_exc
+                exc_tb = sys.last_exc.__traceback__
+    """
+
+    @property
+    def name(self) -> str:
+        return "org.openrewrite.python.migrate.ReplaceSysLastExcInfo"
+
+    @property
+    def display_name(self) -> str:
+        return "Replace `sys.last_type` / `sys.last_value` / `sys.last_traceback` with `sys.last_exc`"
+
+    @property
+    def description(self) -> str:
+        return (
+            "`sys.last_type`, `sys.last_value`, and `sys.last_traceback` were "
+            "deprecated in Python 3.12. "
+            "Replace reads of them with their `sys.last_exc`-based equivalents: "
+            "`type(sys.last_exc)`, `sys.last_exc`, and `sys.last_exc.__traceback__` "
+            "respectively, and a `hasattr(sys, \"last_type\")` guard with "
+            "`hasattr(sys, \"last_exc\")`. Assignment, `del`, `for` and `with` targets "
+            "are left alone, and so is every read in a file that assigns or deletes "
+            "one of the attributes, since `sys.last_exc` would not hold what it set. "
+            "`sys.last_type` is left alone where `type` is shadowed."
+        )
+
+    @property
+    def tags(self) -> List[str]:
+        return ["python", "migration", "3.12", "sys"]
+
+    def editor(self) -> TreeVisitor[Any, ExecutionContext]:
+        class Visitor(PythonVisitor[ExecutionContext]):
+            def visit_compilation_unit(self, cu: CompilationUnit, p: ExecutionContext) -> J:
+                finder = _WriteFinder()
+                finder.visit(cu, p)
+                if finder.found:
+                    return cu
+                return super().visit_compilation_unit(cu, p)
+
+            def visit_field_access(self, field_access: FieldAccess, p: ExecutionContext) -> J:
+                fa = super().visit_field_access(field_access, p)
+                if not isinstance(fa, FieldAccess):
+                    return fa
+                member = _sys_attribute(self, fa)
+                return fa if member is None else self._replace(fa, member)
+
+            def visit_identifier(self, ident: Identifier, p: ExecutionContext) -> J:
+                i = super().visit_identifier(ident, p)
+                if not isinstance(i, Identifier):
+                    return i
+                binding = import_bindings(self).reference(self.cursor, i)
+                if binding is None or binding.module != "sys" or binding.member not in _REPLACEMENTS:
+                    return i
+                if _is_written(self.cursor):
+                    return i
+                replaced = self._replace(i, binding.member)
+                if replaced is not i:
+                    maybe_remove_import(self, RemoveImportOptions(module="sys", name=binding.member))
+                return replaced
+
+            def visit_method_invocation(self, method: MethodInvocation, p: ExecutionContext) -> J:
+                m = super().visit_method_invocation(method, p)
+                if not isinstance(m, MethodInvocation) or not _HASATTR.matches(m, cursor=self.cursor):
+                    return m
+                if len(m.arguments) != 2:
+                    return m
+                receiver, attribute = m.arguments
+                if not isinstance(receiver, Identifier) or not isinstance(attribute, Literal):
+                    return m
+                binding = import_bindings(self).reference(Cursor(self.cursor, receiver), receiver)
+                if binding is None or binding.module != "sys" or binding.member is not None:
+                    return m
+                if attribute.value not in _REPLACEMENTS or attribute.value_source is None:
+                    return m
+                guard = attribute.replace(
+                    value="last_exc",
+                    value_source=attribute.value_source.replace(str(attribute.value), "last_exc"),
+                )
+                arguments = m.padding.arguments
+                padded = arguments.padding.elements
+                padded = [padded[0], padded[1].replace(_element=guard)]
+                return m.padding.replace(_arguments=arguments.padding.replace(elements=padded))
+
+            def _replace(self, tree: J, member: str) -> J:
+                if member == "last_type" and scope_of(self.cursor).declares("type"):
+                    return tree
+                try:
+                    return _REPLACEMENTS[member].apply(self.cursor, visitor=self) or tree
+                except ValueError:
+                    # The template refuses a file where `sys` is bound to something else.
+                    return tree
+
+        return Preconditions.check(uses_import("sys"), Visitor())
+
+
+class _WriteFinder(PythonVisitor[ExecutionContext]):
+    """Finds an assignment to or ``del`` of one of the deprecated ``sys`` attributes."""
+
+    found = False
+
+    def visit_field_access(self, field_access: FieldAccess, p: ExecutionContext) -> J:
+        if not self.found and _sys_attribute(self, field_access) is not None and _is_written(self.cursor):
+            self.found = True
+        return super().visit_field_access(field_access, p)
+
+
+def _sys_attribute(visitor: PythonVisitor, field_access: FieldAccess) -> str | None:
+    """The deprecated attribute ``field_access`` names on the ``sys`` module, if it does."""
+    if not isinstance(field_access.target, Identifier) or field_access.name.simple_name not in _REPLACEMENTS:
+        return None
+    binding = import_bindings(visitor).reference(visitor.cursor, field_access.target)
+    if binding is None or binding.module != "sys" or binding.member is not None:
+        return None
+    return field_access.name.simple_name
+
+
+def _is_written(cursor: Cursor) -> bool:
+    """Whether the expression at ``cursor`` is assigned or deleted rather than read."""
+    node = cursor.value
+    parent = cursor.parent_tree_cursor()
+    while True:
+        holder = parent.value
+        if isinstance(holder, TypeHintedExpression):
+            return holder.expression is node
+        if not isinstance(holder, (Parentheses, Star, CollectionLiteral, ExpressionStatement)):
+            break
+        node = holder
+        parent = parent.parent_tree_cursor()
+    target = parent.value
+    if isinstance(target, (Assignment, AssignmentOperation)):
+        return target.variable is node
+    if isinstance(target, ChainedAssignment):
+        return any(variable is node for variable in target.variables)
+    if isinstance(target, ForEachLoop.Control):
+        return target.variable is node
+    if isinstance(target, ComprehensionExpression.Clause):
+        return target.iterator_variable is node
+    return isinstance(target, Del)

{openrewrite_migrate_python-0.17.0.dev20261021175539 → openrewrite_migrate_python-0.17.0.dev20261022150922}/src/openrewrite_migrate_python/migrate/upgrade_to_python38.py

@@ -22,8 +22,8 @@ class UpgradeToPython38(Recipe):
 
     Key changes:
     - Replace ``time.clock()`` with ``time.perf_counter()``
-    - Replace ``cgi.escape()`` with ``html.escape()``, which also escapes quotes unless
-      called with ``quote=False``
+    - Replace ``cgi.escape()`` with ``html.escape()``, passing ``quote=False`` where the
+      call relied on ``cgi.escape()`` leaving quotes alone
     - Replace ``cgi.parse_qs()`` / ``cgi.parse_qsl()`` with ``urllib.parse`` equivalents
     - Replace ``platform.popen()`` with ``subprocess.check_output()``
     - Replace ``tarfile.filemode`` with ``stat.filemode``
@@ -48,8 +48,8 @@ class UpgradeToPython38(Recipe):
     def description(self) -> str:
         return (
             "Migrate deprecated APIs and detect legacy patterns for Python 3.8 compatibility. "
-            "`cgi.escape()` becomes `html.escape()`, which also escapes quotes unless called "
-            "with `quote=False`."
+            "`cgi.escape()` becomes `html.escape()`, with `quote=False` where the call relied "
+            "on `cgi.escape()` leaving quotes alone."
         )
 
     @property
@@ -58,6 +58,7 @@ class UpgradeToPython38(Recipe):
 
     def recipe_list(self) -> List[Recipe]:
         """Return the list of recipes to apply for Python 3.8 upgrade."""
+        from .cgi_escape_deprecations import ReplaceCgiEscape
         from .cgi_parse_deprecations import ReplaceCgiParseQs, ReplaceCgiParseQsl
         from .functools_deprecations import FindFunctoolsCmpToKey
         from .future_imports import RemoveFutureImports
@@ -69,8 +70,8 @@ class UpgradeToPython38(Recipe):
         return [
             # Auto-fix: time.clock() -> time.perf_counter()
             ChangeImport(old_module="time", old_name="clock", new_module="time", new_name="perf_counter"),
-            # Auto-fix: cgi.escape() -> html.escape(), which also escapes quotes by default
-            ChangeImport(old_module="cgi", old_name="escape", new_module="html"),
+            # Auto-fix: cgi.escape() -> html.escape(..., quote=False)
+            ReplaceCgiEscape(),
             # Auto-fix: cgi.parse_qs() / cgi.parse_qsl() -> urllib.parse
             ReplaceCgiParseQs(),
             ReplaceCgiParseQsl(),

{openrewrite_migrate_python-0.17.0.dev20261021175539 → openrewrite_migrate_python-0.17.0.dev20261022150922}/src/openrewrite_migrate_python.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openrewrite-migrate-python
-Version: 0.17.0.dev20261021175539
+Version: 0.17.0.dev20261022150922
 Summary: OpenRewrite recipes for migrating Python codebases to newer Python versions.
 Author-email: "Moderne Inc." <support@moderne.io>
 License: Moderne Proprietary

{openrewrite_migrate_python-0.17.0.dev20261021175539 → openrewrite_migrate_python-0.17.0.dev20261022150922}/src/openrewrite_migrate_python.egg-info/SOURCES.txt

@@ -72,6 +72,7 @@ src/openrewrite_migrate_python/migrate/asyncio_deprecations.py
 src/openrewrite_migrate_python/migrate/avro_migrations.py
 src/openrewrite_migrate_python/migrate/backoff_to_tenacity.py
 src/openrewrite_migrate_python/migrate/calendar_deprecations.py
+src/openrewrite_migrate_python/migrate/cgi_escape_deprecations.py
 src/openrewrite_migrate_python/migrate/cgi_migrations.py
 src/openrewrite_migrate_python/migrate/cgi_parse_deprecations.py
 src/openrewrite_migrate_python/migrate/collections_abc_migrations.py
@@ -147,6 +148,7 @@ tests/test_asyncio_deprecations.py
 tests/test_avro_migrations.py
 tests/test_backoff_to_tenacity.py
 tests/test_calendar_deprecations.py
+tests/test_cgi_escape_deprecations.py
 tests/test_cgi_parse_deprecations.py
 tests/test_change_import_recipes.py
 tests/test_collections_abc_migrations.py