✨ feature: add pep701 support and remove python3.8

.github/workflows/publish.yml

@@ -10,7 +10,7 @@ jobs:
   build:
     strategy:
       matrix:
-        target-version: [py38, py39, py310, py311, py312]
+        target-version: [py39, py310, py311, py312]
     runs-on: ubuntu-latest
     permissions:
       id-token: write

.pre-commit-config.yaml

@@ -19,7 +19,7 @@ repos:
       - id: ruff-format
 
   - repo: https://github.com/pdm-project/pdm
-    rev: 2.10.4
+    rev: 2.11.1
     hooks:
       - id: pdm-lock-check
 

pyfuture/codemod/__init__.py

@@ -1,3 +1,4 @@
 from .pep604 import TransformUnionTypesCommand
 from .pep622 import TransformMatchCommand
 from .pep695 import TransformTypeParametersCommand
+from .pep701 import TransformFStringCommand

pyfuture/codemod/pep701/__init__.py

@@ -0,0 +1 @@
+from .fstring import TransformFStringCommand

pyfuture/codemod/pep701/fstring.py

@@ -0,0 +1,126 @@
+from __future__ import annotations
+
+from typing import Any
+
+import libcst as cst
+from libcst import (
+    Arg,
+    ClassDef,
+    FunctionDef,
+    Index,
+    Name,
+    SimpleStatementLine,
+    Subscript,
+    SubscriptElement,
+)
+from libcst.codemod import (
+    CodemodContext,
+    VisitorBasedCodemodCommand,
+)
+from libcst.codemod.visitors import AddImportsVisitor
+from libcst.metadata import ScopeProvider
+
+from ..utils import gen_type_param
+
+
+class TransformFStringCommand(VisitorBasedCodemodCommand):
+    """
+    Remove f-string from node, and return a new node with the formatted string.
+
+    Example:
+    >>> transformer = TransformFStringCommand(CodemodContext())
+    >>> module = cst.parse_module(\"""
+    ... name = "world"
+    ... x = f"hello {name}"
+    ... y = f"hello {"world"}"
+    ... \"""
+    ... )
+    >>> new_module = transformer.transform_module(module)
+    >>> print(new_module.code)
+    name = "world"
+    x = "hello {:}".format(name)
+    y = "hello {:}".format("world")
+    >>> module = cst.parse_module(\"""
+    ... result = 3.1415926
+    ... x = f"result: {result:.2f}"
+    ... y = f"result: {3.1415926:.2f}"
+    ... \"""
+    ... )
+    >>> new_module = transformer.transform_module(module)
+    >>> print(new_module.code)
+    result = 3.1415926
+    x = "result: {:.2f}".format(result)
+    y = "result: {:.2f}".format(3.1415926)
+    """
+
+    METADATA_DEPENDENCIES = (ScopeProvider,)
+
+    def __init__(self, context: CodemodContext) -> None:
+        self.node_to_wrapper: dict[FunctionDef | ClassDef, Any] = {}
+        super().__init__(context)
+
+    def remove_type_parameters[T: FunctionDef | ClassDef](
+        self, node: T, prefix: str = "", suffix: str = ""
+    ) -> tuple[list[SimpleStatementLine], T]:
+        type_params = node.type_parameters
+        if type_params is None:
+            return [], node
+        statements = []
+        new_node = node.with_changes(type_parameters=None)
+
+        slices = []
+        for type_param in type_params.params:
+            new_name = type_param.param.name.with_changes(value=f"{prefix}{type_param.param.name.value}{suffix}")
+
+            AddImportsVisitor.add_needed_import(self.context, "typing", type_param.param.__class__.__name__)
+            statements.append(gen_type_param(type_param.param, new_name))
+            slices.append(
+                SubscriptElement(
+                    slice=Index(value=new_name),
+                ),
+            )
+
+        if isinstance(new_node, ClassDef) and slices:
+            AddImportsVisitor.add_needed_import(self.context, "typing", "Generic")
+            generic_base = Arg(
+                value=Subscript(
+                    value=Name(
+                        value="Generic",
+                        lpar=[],
+                        rpar=[],
+                    ),
+                    slice=slices,
+                )
+            )
+            new_node = new_node.with_changes(bases=[*new_node.bases, generic_base])
+
+        return statements, new_node
+
+    def leave_FormattedString(self, original_node: cst.FormattedString, updated_node: cst.FormattedString):
+        expressions = []
+        string = ""
+        start = updated_node.start.strip("f")
+        end = updated_node.end
+
+        for node in updated_node.parts:
+            if isinstance(node, cst.FormattedStringExpression):
+                expressions.append(node.expression)
+                format_spec_str = ""
+                if (format_spec := node.format_spec) is not None:
+                    for format_spec_node in format_spec:
+                        if isinstance(format_spec_node, cst.FormattedStringText):
+                            format_spec_str += format_spec_node.value
+                        else:
+                            raise NotImplementedError(f"Unknown node type: {format_spec_node}")
+                string += f"{{:{format_spec_str}}}"
+            elif isinstance(node, cst.FormattedStringText):
+                string += node.value
+            else:
+                raise NotImplementedError(f"Unknown node type: {node}")
+        return cst.Call(
+            func=cst.Attribute(
+                value=cst.SimpleString(value=f"{start}{string}{end}"),
+                attr=cst.Name(value="format"),
+            ),
+            args=[cst.Arg(value=expression) for expression in expressions],
+        )

pyfuture/codemod/utils.py

@@ -13,6 +13,7 @@ class RuleSet(Enum):
     pep622 = "pep622"
     # python 3.12+
     pep695 = "pep695"
+    pep701 = "pep701"
 
 
 def get_transformers(rule_sets: list[RuleSet] | RuleSet) -> Iterable[type[Codemod]]:
@@ -27,6 +28,7 @@ def get_transformers(rule_sets: list[RuleSet] | RuleSet) -> Iterable[type[Codemo
     from .pep604 import TransformUnionTypesCommand
     from .pep622 import TransformMatchCommand
     from .pep695 import TransformTypeParametersCommand
+    from .pep701 import TransformFStringCommand
 
     if not isinstance(rule_sets, list):
         rule_sets = [rule_sets]
@@ -39,6 +41,8 @@ def get_transformers(rule_sets: list[RuleSet] | RuleSet) -> Iterable[type[Codemo
                 yield TransformMatchCommand
             case RuleSet.pep695:
                 yield TransformTypeParametersCommand
+            case RuleSet.pep701:
+                yield TransformFStringCommand
             case _:  # pragma: no cover
                 raise ValueError(f"Unknown rule set: {rule_set}")
 

pyfuture/utils.py

@@ -45,7 +45,7 @@ def test(x: __test_T) -> __test_T:
 def transfer_code(
     code: str,
     *,
-    target: tuple[int, int] = (3, 8),
+    target: tuple[int, int] = (3, 9),
 ) -> str:
     """
     Transfer code to specified target version of python.
@@ -66,7 +66,7 @@ def test(x: __test_T) -> __test_T:
     assert target[0] == 3, "Only support python3"
     transformers = []
     if target[1] < 12:
-        transformers.extend(get_transformers(RuleSet.pep695))
+        transformers.extend(get_transformers([RuleSet.pep695, RuleSet.pep701]))
     if target[1] < 10:
         transformers.extend(get_transformers([RuleSet.pep622, RuleSet.pep604]))
     new_code = apply_transformer(
@@ -80,7 +80,7 @@ def transfer_file(
     src_file: Path,
     tgt_file: Path,
     *,
-    target: tuple[int, int] = (3, 8),
+    target: tuple[int, int] = (3, 9),
 ):
     """
     Transfer code from src_file and write to tgt_file.

pyproject.toml

@@ -6,12 +6,12 @@ authors = [
     {name = "Zhan Rongrui", email = "2742392377@qq.com"},
 ]
 dependencies = [
-    "libcst>=1.1.0",
+    "libcst>=1.2.0",
     "typer>=0.9.0",
     "loguru>=0.7.2",
     "rich>=13.7.0",
 ]
-requires-python = ">=3.8"
+requires-python = ">=3.9"
 readme = "README.md"
 license = {text = "MIT"}