openrewrite-migrate-python 0.14.0.dev20260902102558__tar.gz → 0.14.0.dev20260902105951__tar.gz

{openrewrite_migrate_python-0.14.0.dev20260902102558 → openrewrite_migrate_python-0.14.0.dev20260902105951}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openrewrite-migrate-python
-Version: 0.14.0.dev20260902102558
+Version: 0.14.0.dev20260902105951
 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.14.0.dev20260902102558 → openrewrite_migrate_python-0.14.0.dev20260902105951}/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.14.0.dev20260902102558"  # Updated dynamically during release
+version = "0.14.0.dev20260902105951"  # Updated dynamically during release
 authors = [{ name = "Moderne Inc.", email = "support@moderne.io" }]
 license = { text = "Moderne Proprietary" }
 readme = "README.md"

openrewrite_migrate_python-0.14.0.dev20260902105951/src/openrewrite_migrate_python/migrate/datetime_utc.py

@@ -0,0 +1,274 @@
+"""
+Recipes for migrating deprecated datetime.utcnow() and datetime.utcfromtimestamp() calls.
+
+These methods are deprecated in Python 3.12+ because they return naive datetime objects
+that don't carry timezone information. The recommended replacements are:
+
+- datetime.utcnow() -> datetime.now(UTC)
+- datetime.utcfromtimestamp(ts) -> datetime.fromtimestamp(ts, UTC)
+
+The replacements are timezone-aware where the deprecated calls were naive, so values already
+stored or compared as naive UTC need migrating alongside the call sites.
+
+See: https://docs.python.org/3/library/datetime.html#datetime.datetime.utcnow
+"""
+
+from functools import lru_cache
+from typing import Any, Dict, Iterable, List, Optional, Tuple, cast
+
+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.add_import import AddImportOptions, maybe_add_import
+from rewrite.python.import_utils import get_alias_name, get_name_string, get_qualid_name
+from rewrite.python.preconditions import uses_import
+from rewrite.python.scope_utils import LocalBindings
+from rewrite.python.visitor import PythonVisitor
+from rewrite.python.template import Template, capture, raw, template
+from rewrite.python.tree import CompilationUnit, MultiImport, NamedArgument
+from rewrite.java.tree import (
+    Block, Empty, FieldAccess, Identifier, Import, J, MethodDeclaration, MethodInvocation,
+)
+
+# Define category path: Python > Migrate > Python 3.12
+_Python312 = [
+    *Python,
+    CategoryDescriptor(display_name="Migrate"),
+    CategoryDescriptor(display_name="Python 3.12"),
+]
+
+_sel = capture('sel')
+_ts = capture('ts')
+
+# Names `datetime` exports for UTC, each with the expression reaching it, in preference
+# order: `timezone` is the one Django code routinely binds to `django.utils.timezone`.
+_UTC_NAMES: Tuple[Tuple[str, str], ...] = (("UTC", "UTC"), ("timezone", "timezone.utc"))
+
+_DATETIME_CLASS = ("datetime", "datetime")
+_DATETIME_MODULE = (None, "datetime")
+
+
+@lru_cache(maxsize=None)
+def _now_template(utc: str) -> Template:
+    return template(f"{_sel}.now({raw(utc)})")
+
+
+@lru_cache(maxsize=None)
+def _fromtimestamp_template(utc: str) -> Template:
+    return template(f"{_sel}.fromtimestamp({_ts}, {raw(utc)})")
+
+
+def _import_bindings(statements: Iterable[J]) -> Dict[str, Tuple[Optional[str], str]]:
+    """Every name the imports among ``statements`` bind, mapped to the ``(from, name)`` pair it
+    was imported as -- ``(None, 'datetime')`` for ``import datetime``."""
+    bindings: Dict[str, Tuple[Optional[str], str]] = {}
+
+    def record(imp: Import, from_: Optional[str]) -> None:
+        name = get_qualid_name(imp.qualid)
+        bindings[get_alias_name(imp) or name.split('.')[0]] = (from_, name)
+
+    for stmt in statements:
+        if isinstance(stmt, MultiImport):
+            from_ = get_name_string(stmt.from_) if stmt.from_ is not None else None
+            for imp in stmt.names:
+                record(imp, from_)
+        elif isinstance(stmt, Import):
+            record(stmt, None)
+    return bindings
+
+
+def _enclosing_function_body(cursor: Optional[Cursor]) -> List[J]:
+    """The statements of the innermost function enclosing ``cursor``, empty outside one."""
+    while cursor is not None:
+        value = cursor.value
+        if isinstance(value, MethodDeclaration):
+            return list(value.body.statements) if isinstance(value.body, Block) else []
+        cursor = cursor.parent
+    return []
+
+
+class _DatetimeUtcVisitor(PythonVisitor[ExecutionContext]):
+    """Rewrites a naive UTC constructor to its aware counterpart, spelling UTC the way the
+    file's own ``datetime`` imports allow. Those imports also identify the receiver, which a
+    parse that attributes no types still supplies.
+    """
+
+    _target = ""
+
+    def __init__(self) -> None:
+        super().__init__()
+        self._bindings: Dict[str, Tuple[Optional[str], str]] = {}
+        self._locals = LocalBindings()
+
+    def visit_compilation_unit(self, cu: CompilationUnit, p: ExecutionContext) -> J:
+        self._bindings = _import_bindings(cu.statements)
+        self._locals = LocalBindings()
+        return super().visit_compilation_unit(cu, p)
+
+    def targets_datetime(self, method: MethodInvocation) -> bool:
+        if not isinstance(method.name, Identifier) or method.name.simple_name != self._target:
+            return False
+        select = method.select
+        if isinstance(select, Identifier):
+            return self._resolves(select.simple_name, _DATETIME_CLASS)
+        if isinstance(select, FieldAccess) and select.name.simple_name == "datetime":
+            return self._resolves(get_name_string(select.target), _DATETIME_MODULE)
+        return False
+
+    def _resolves(self, name: str, binding: Tuple[Optional[str], str]) -> bool:
+        if not self._locals.is_bound(self.cursor, name):
+            return self._bindings.get(name) == binding
+        # A deferred `from datetime import datetime` shadows the module-level name with the
+        # same class, so the receiver is still `datetime.datetime`.
+        return _import_bindings(_enclosing_function_body(self.cursor)).get(name) == binding
+
+    def utc_reference(self, select: Optional[J]) -> Optional[str]:
+        """An expression evaluating to ``datetime.UTC`` at ``select``'s call site, registering an
+        import if one is needed, or None when no name is free to bind it to."""
+        if isinstance(select, FieldAccess):
+            # `import datetime` puts UTC on the same module the class was reached through.
+            return f"{get_name_string(select.target)}.UTC"
+
+        # The expression is emitted at the call site, where an enclosing scope's binding of
+        # the name wins over the module-level import it would otherwise reach.
+        free = [(n, e) for n, e in _UTC_NAMES if not self._locals.is_bound(self.cursor, n)]
+
+        for name, expression in free:
+            if self._bindings.get(name) == ("datetime", name):
+                return expression
+
+        for name, expression in free:
+            if name not in self._bindings:
+                maybe_add_import(
+                    self,
+                    AddImportOptions(module="datetime", name=name, only_if_referenced=False),
+                )
+                return expression
+
+        return None
+
+
+@categorize(_Python312)
+class ReplaceDatetimeUtcNow(Recipe):
+    """
+    Replace `datetime.utcnow()` with `datetime.now(UTC)`.
+
+    The `datetime.utcnow()` method is deprecated in Python 3.12 because it returns
+    a naive datetime object that doesn't carry timezone information. This can lead
+    to subtle bugs when comparing or converting between timezones.
+
+    Example:
+        Before:
+            from datetime import datetime
+            now = datetime.utcnow()
+
+        After:
+            from datetime import datetime, UTC
+            now = datetime.now(UTC)
+    """
+
+    @property
+    def name(self) -> str:
+        return "org.openrewrite.python.migrate.ReplaceDatetimeUtcNow"
+
+    @property
+    def display_name(self) -> str:
+        return "Replace `datetime.utcnow()` with `datetime.now(UTC)`"
+
+    @property
+    def description(self) -> str:
+        return (
+            "The `datetime.utcnow()` method is deprecated in Python 3.12. "
+            "Replace it with `datetime.now(UTC)`, importing `UTC` from `datetime` where the "
+            "name is not already in scope. The result is timezone-aware where `utcnow()` was "
+            "naive, so stored or compared values may need migrating alongside the call sites."
+        )
+
+    @property
+    def tags(self) -> List[str]:
+        return ["python", "migration", "3.12", "datetime"]
+
+    def editor(self) -> TreeVisitor[Any, ExecutionContext]:
+        class Visitor(_DatetimeUtcVisitor):
+            _target = "utcnow"
+
+            def visit_method_invocation(
+                self, method: MethodInvocation, p: ExecutionContext
+            ) -> J:
+                method = cast(MethodInvocation, super().visit_method_invocation(method, p))
+                if not self.targets_datetime(method):
+                    return method
+                utc = self.utc_reference(method.select)
+                if utc is None:
+                    return method
+                replaced = _now_template(utc).apply(self.cursor, values={'sel': method.select})
+                return replaced if replaced is not None else method
+
+        return Preconditions.check(uses_import("datetime"), Visitor())
+
+
+@categorize(_Python312)
+class ReplaceDatetimeUtcFromTimestamp(Recipe):
+    """
+    Replace `datetime.utcfromtimestamp(ts)` with `datetime.fromtimestamp(ts, UTC)`.
+
+    The `datetime.utcfromtimestamp()` method is deprecated in Python 3.12 because it
+    returns a naive datetime object.
+
+    Example:
+        Before:
+            from datetime import datetime
+            dt = datetime.utcfromtimestamp(1234567890)
+
+        After:
+            from datetime import datetime, UTC
+            dt = datetime.fromtimestamp(1234567890, UTC)
+    """
+
+    @property
+    def name(self) -> str:
+        return "org.openrewrite.python.migrate.ReplaceDatetimeUtcFromTimestamp"
+
+    @property
+    def display_name(self) -> str:
+        return "Replace `datetime.utcfromtimestamp()` with `datetime.fromtimestamp(ts, UTC)`"
+
+    @property
+    def description(self) -> str:
+        return (
+            "The `datetime.utcfromtimestamp()` method is deprecated in Python 3.12. "
+            "Replace it with `datetime.fromtimestamp(ts, UTC)`, importing `UTC` from "
+            "`datetime` where the name is not already in scope. The result is timezone-aware "
+            "where `utcfromtimestamp()` was naive, so stored or compared values may need "
+            "migrating alongside the call sites."
+        )
+
+    @property
+    def tags(self) -> List[str]:
+        return ["python", "migration", "3.12", "datetime"]
+
+    def editor(self) -> TreeVisitor[Any, ExecutionContext]:
+        class Visitor(_DatetimeUtcVisitor):
+            _target = "utcfromtimestamp"
+
+            def visit_method_invocation(
+                self, method: MethodInvocation, p: ExecutionContext
+            ) -> J:
+                method = cast(MethodInvocation, super().visit_method_invocation(method, p))
+                if not self.targets_datetime(method):
+                    return method
+                # The tz the template appends is positional, so it cannot follow a keyword one.
+                if len(method.arguments) != 1 or isinstance(
+                    method.arguments[0], (Empty, NamedArgument)
+                ):
+                    return method
+                utc = self.utc_reference(method.select)
+                if utc is None:
+                    return method
+                replaced = _fromtimestamp_template(utc).apply(
+                    self.cursor, values={'sel': method.select, 'ts': method.arguments[0]}
+                )
+                return replaced if replaced is not None else method
+
+        return Preconditions.check(uses_import("datetime"), Visitor())

{openrewrite_migrate_python-0.14.0.dev20260902102558 → openrewrite_migrate_python-0.14.0.dev20260902105951}/src/openrewrite_migrate_python.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openrewrite-migrate-python
-Version: 0.14.0.dev20260902102558
+Version: 0.14.0.dev20260902105951
 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.14.0.dev20260902105951/tests/test_datetime_utc.py

@@ -0,0 +1,225 @@
+"""Tests for datetime UTC migration recipes."""
+
+from rewrite.test import RecipeSpec, python
+from openrewrite_migrate_python.migrate.datetime_utc import (
+    ReplaceDatetimeUtcNow,
+    ReplaceDatetimeUtcFromTimestamp,
+)
+
+class TestReplaceDatetimeUtcNow:
+    """Tests for the ReplaceDatetimeUtcNow recipe."""
+
+    def test_binds_utc_when_datetime_class_imported(self):
+        """`from datetime import datetime` leaves no name for UTC, so one is imported."""
+        spec = RecipeSpec(recipe=ReplaceDatetimeUtcNow())
+        spec.rewrite_run(
+            python(
+                """
+                from datetime import datetime
+                now = datetime.utcnow()
+                """,
+                """
+                from datetime import datetime, UTC
+                now = datetime.now(UTC)
+                """,
+            )
+        )
+
+    def test_reuses_imported_timezone(self):
+        """An existing `datetime.timezone` binding is used instead of a new import."""
+        spec = RecipeSpec(recipe=ReplaceDatetimeUtcNow())
+        spec.rewrite_run(
+            python(
+                """
+                from datetime import datetime, timezone
+                now = datetime.utcnow()
+                """,
+                """
+                from datetime import datetime, timezone
+                now = datetime.now(timezone.utc)
+                """,
+            )
+        )
+
+    def test_qualifies_through_the_module_binding(self):
+        """`import datetime` binds the module, so `UTC` is reachable without an import."""
+        spec = RecipeSpec(recipe=ReplaceDatetimeUtcNow())
+        spec.rewrite_run(
+            python(
+                """
+                import datetime
+                now = datetime.datetime.utcnow()
+                """,
+                """
+                import datetime
+                now = datetime.datetime.now(datetime.UTC)
+                """,
+            )
+        )
+
+    def test_keeps_the_alias_of_an_aliased_class_import(self):
+        spec = RecipeSpec(recipe=ReplaceDatetimeUtcNow())
+        spec.rewrite_run(
+            python(
+                """
+                from datetime import datetime as dt
+                now = dt.utcnow()
+                """,
+                """
+                from datetime import datetime as dt, UTC
+                now = dt.now(UTC)
+                """,
+            )
+        )
+
+    def test_falls_back_to_timezone_when_utc_names_something_else(self):
+        """Importing `datetime.UTC` here would rebind pytz's `UTC` for the whole file."""
+        spec = RecipeSpec(recipe=ReplaceDatetimeUtcNow())
+        spec.rewrite_run(
+            python(
+                """
+                from datetime import datetime
+                from pytz import UTC
+
+                now = datetime.utcnow()
+                """,
+                """
+                from datetime import datetime, timezone
+                from pytz import UTC
+
+                now = datetime.now(timezone.utc)
+                """,
+            )
+        )
+
+    def test_falls_back_to_timezone_when_utc_is_locally_rebound(self):
+        """`UTC` would reach the local at the call site, whatever the import binds it to."""
+        spec = RecipeSpec(recipe=ReplaceDatetimeUtcNow())
+        spec.rewrite_run(
+            python(
+                """
+                from datetime import datetime
+
+
+                def stamp():
+                    UTC = "Z"
+                    return UTC, datetime.utcnow()
+                """,
+                """
+                from datetime import datetime, timezone
+
+
+                def stamp():
+                    UTC = "Z"
+                    return UTC, datetime.now(timezone.utc)
+                """,
+            )
+        )
+
+    def test_no_change_when_both_utc_names_are_taken(self):
+        """With no free name and none bound to `datetime`, there is nothing safe to emit."""
+        spec = RecipeSpec(recipe=ReplaceDatetimeUtcNow())
+        spec.rewrite_run(
+            python(
+                """
+                from datetime import datetime
+                from django.utils import timezone
+                from pytz import UTC
+
+                now = datetime.utcnow()
+                """
+            )
+        )
+
+    def test_rewrites_under_a_function_local_import(self):
+        """A deferred `from datetime import datetime` binds the same class the module one does."""
+        spec = RecipeSpec(recipe=ReplaceDatetimeUtcNow())
+        spec.rewrite_run(
+            python(
+                """
+                def cutoff(max_age):
+                    from datetime import datetime, timedelta
+
+                    return datetime.utcnow() - timedelta(seconds=max_age)
+                """,
+                """
+                from datetime import UTC
+                def cutoff(max_age):
+                    from datetime import datetime, timedelta
+
+                    return datetime.now(UTC) - timedelta(seconds=max_age)
+                """,
+            )
+        )
+
+    def test_no_change_when_the_receiver_is_locally_rebound(self):
+        """The parameter shadows the import, so `datetime` here is not the class."""
+        spec = RecipeSpec(recipe=ReplaceDatetimeUtcNow())
+        spec.rewrite_run(
+            python(
+                """
+                from datetime import datetime
+
+                def render(datetime):
+                    return datetime.utcnow()
+                """
+            )
+        )
+
+    def test_no_change_when_regular_now(self):
+        """Test that datetime.now() is not marked."""
+        spec = RecipeSpec(recipe=ReplaceDatetimeUtcNow())
+        spec.rewrite_run(
+            python(
+                """
+                from datetime import datetime
+                now = datetime.now()
+                """
+            )
+        )
+
+    def test_no_change_when_different_module(self):
+        """Test that utcnow on a different object is not marked."""
+        spec = RecipeSpec(recipe=ReplaceDatetimeUtcNow())
+        spec.rewrite_run(
+            python(
+                """
+                class MyClass:
+                    def utcnow(self):
+                        return "not datetime"
+
+                obj = MyClass()
+                result = obj.utcnow()
+                """
+            )
+        )
+
+class TestReplaceDatetimeUtcFromTimestamp:
+    """Tests for the ReplaceDatetimeUtcFromTimestamp recipe."""
+
+    def test_appends_utc_argument(self):
+        spec = RecipeSpec(recipe=ReplaceDatetimeUtcFromTimestamp())
+        spec.rewrite_run(
+            python(
+                """
+                from datetime import datetime
+                dt = datetime.utcfromtimestamp(1234567890)
+                """,
+                """
+                from datetime import datetime, UTC
+                dt = datetime.fromtimestamp(1234567890, UTC)
+                """,
+            )
+        )
+
+    def test_no_change_when_regular_fromtimestamp(self):
+        """Test that datetime.fromtimestamp() is not marked."""
+        spec = RecipeSpec(recipe=ReplaceDatetimeUtcFromTimestamp())
+        spec.rewrite_run(
+            python(
+                """
+                from datetime import datetime
+                dt = datetime.fromtimestamp(1234567890)
+                """
+            )
+        )

openrewrite_migrate_python-0.14.0.dev20260902102558/src/openrewrite_migrate_python/migrate/datetime_utc.py

@@ -1,137 +0,0 @@
-"""
-Recipes for migrating deprecated datetime.utcnow() and datetime.utcfromtimestamp() calls.
-
-These methods are deprecated in Python 3.12+ because they return naive datetime objects
-that don't carry timezone information. The recommended replacements are:
-
-- datetime.utcnow() -> datetime.now(datetime.UTC)
-- datetime.utcfromtimestamp(ts) -> datetime.fromtimestamp(ts, datetime.UTC)
-
-See: https://docs.python.org/3/library/datetime.html#datetime.datetime.utcnow
-"""
-
-from typing import Any, Optional
-
-from rewrite import ExecutionContext, Preconditions, Recipe, TreeVisitor
-from rewrite.category import CategoryDescriptor
-from rewrite.decorators import categorize
-from rewrite.marketplace import Python
-from rewrite.python.preconditions import uses_import
-from rewrite.python.visitor import PythonVisitor
-from rewrite.python.template import pattern, template, capture
-from rewrite.java.tree import MethodInvocation
-
-# Define category path: Python > Migrate > Python 3.12
-_Python312 = [
-    *Python,
-    CategoryDescriptor(display_name="Migrate"),
-    CategoryDescriptor(display_name="Python 3.12"),
-]
-
-# Pattern/template pairs for datetime.utcnow() -> datetime.now(datetime.UTC)
-_utcnow_pattern = pattern("datetime.utcnow()")
-_utcnow_template = template("datetime.now(datetime.UTC)")
-
-# Pattern/template pairs for datetime.utcfromtimestamp(ts) -> datetime.fromtimestamp(ts, datetime.UTC)
-_ts = capture('ts')
-_utcfromtimestamp_pattern = pattern("datetime.utcfromtimestamp({ts})", ts=_ts)
-_utcfromtimestamp_template = template("datetime.fromtimestamp({ts}, datetime.UTC)", ts=_ts)
-
-
-@categorize(_Python312)
-class ReplaceDatetimeUtcNow(Recipe):
-    """
-    Replace `datetime.utcnow()` with `datetime.now(datetime.UTC)`.
-
-    The `datetime.utcnow()` method is deprecated in Python 3.12 because it returns
-    a naive datetime object that doesn't carry timezone information. This can lead
-    to subtle bugs when comparing or converting between timezones.
-
-    This recipe transforms `datetime.utcnow()` to `datetime.now(datetime.UTC)` which
-    returns a timezone-aware datetime object.
-
-    Example:
-        Before:
-            from datetime import datetime
-            now = datetime.utcnow()
-
-        After:
-            from datetime import datetime
-            now = datetime.now(datetime.UTC)
-    """
-
-    @property
-    def name(self) -> str:
-        return "org.openrewrite.python.migrate.ReplaceDatetimeUtcNow"
-
-    @property
-    def display_name(self) -> str:
-        return "Replace `datetime.utcnow()` with `datetime.now(UTC)`"
-
-    @property
-    def description(self) -> str:
-        return (
-            "The `datetime.utcnow()` method is deprecated in Python 3.12. "
-            "Replace it with `datetime.now(datetime.UTC)` for timezone-aware datetime objects."
-        )
-
-    def editor(self) -> TreeVisitor[Any, ExecutionContext]:
-        class Visitor(PythonVisitor[ExecutionContext]):
-            def visit_method_invocation(
-                self, method: MethodInvocation, p: ExecutionContext
-            ) -> Optional[MethodInvocation]:
-                method = super().visit_method_invocation(method, p)
-                match = _utcnow_pattern.match(method, self.cursor)
-                if match:
-                    return _utcnow_template.apply(self.cursor, values=match)
-                return method
-
-        return Preconditions.check(uses_import("datetime"), Visitor())
-
-
-@categorize(_Python312)
-class ReplaceDatetimeUtcFromTimestamp(Recipe):
-    """
-    Replace `datetime.utcfromtimestamp(ts)` with `datetime.fromtimestamp(ts, datetime.UTC)`.
-
-    The `datetime.utcfromtimestamp()` method is deprecated in Python 3.12 because it
-    returns a naive datetime object. This recipe transforms it to use the timezone-aware
-    `datetime.fromtimestamp(ts, datetime.UTC)` form.
-
-    Example:
-        Before:
-            from datetime import datetime
-            dt = datetime.utcfromtimestamp(1234567890)
-
-        After:
-            from datetime import datetime
-            dt = datetime.fromtimestamp(1234567890, datetime.UTC)
-    """
-
-    @property
-    def name(self) -> str:
-        return "org.openrewrite.python.migrate.ReplaceDatetimeUtcFromTimestamp"
-
-    @property
-    def display_name(self) -> str:
-        return "Replace `datetime.utcfromtimestamp()` with `datetime.fromtimestamp(ts, UTC)`"
-
-    @property
-    def description(self) -> str:
-        return (
-            "The `datetime.utcfromtimestamp()` method is deprecated in Python 3.12. "
-            "Replace it with `datetime.fromtimestamp(ts, datetime.UTC)` for timezone-aware datetime objects."
-        )
-
-    def editor(self) -> TreeVisitor[Any, ExecutionContext]:
-        class Visitor(PythonVisitor[ExecutionContext]):
-            def visit_method_invocation(
-                self, method: MethodInvocation, p: ExecutionContext
-            ) -> Optional[MethodInvocation]:
-                method = super().visit_method_invocation(method, p)
-                match = _utcfromtimestamp_pattern.match(method, self.cursor)
-                if match:
-                    return _utcfromtimestamp_template.apply(self.cursor, values=match)
-                return method
-
-        return Preconditions.check(uses_import("datetime"), Visitor())