wexample-filestate-python 0.0.48__py3-none-any.whl

wexample_filestate_python/option/remove_unused_option.py

@@ -0,0 +1,45 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from wexample_helpers.decorator.base_class import base_class
+
+from .abstract_python_file_content_option import AbstractPythonFileContentOption
+
+if TYPE_CHECKING:
+    from wexample_filestate.const.types_state_items import TargetFileOrDirectoryType
+
+
+@base_class
+class RemoveUnusedOption(AbstractPythonFileContentOption):
+    def get_description(self) -> str:
+        return "Remove unused imports from the Python file using autoflake."
+
+    def _apply_content_change(self, target: TargetFileOrDirectoryType) -> str:
+        """Remove unused Python imports using autoflake."""
+        from wexample_helpers.helpers.shell import shell_run
+        from wexample_helpers.helpers.system import system_get_venv_bin_path
+
+        result = shell_run(
+            cmd=[
+                f"{system_get_venv_bin_path()}/autoflake",
+                "--stdout",
+                "--remove-all-unused-imports",
+                "--remove-unused-variables",
+                "--expand-star-imports",
+                "--remove-duplicate-keys",
+                target.get_path(),
+            ],
+        )
+
+        if result.returncode != 0:
+            # Double line return is important to keep message visible event last line is erased by parent process.
+            target.io.error(f"Autoflake error: {result.stderr}\n\n")
+            return target.get_local_file().read()  # Return original content on error
+
+        modified_content = result.stdout
+
+        if not modified_content.strip():
+            return target.get_local_file().read()  # Return original content if empty
+
+        return modified_content

wexample_filestate_python/option/sort_imports_option.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from wexample_helpers.decorator.base_class import base_class
+
+from .abstract_python_file_content_option import AbstractPythonFileContentOption
+
+if TYPE_CHECKING:
+    from wexample_filestate.const.types_state_items import TargetFileOrDirectoryType
+
+
+@base_class
+class SortImportsOption(AbstractPythonFileContentOption):
+    def get_description(self) -> str:
+        return "Sort and group Python imports using isort."
+
+    def _apply_content_change(self, target: TargetFileOrDirectoryType) -> str:
+        """Sort Python imports using isort."""
+        from isort import code
+        from isort.settings import Config
+
+        src = target.get_local_file().read()
+        config = Config(profile="black")
+        formatted = code(src, config=config)
+        return formatted

wexample_filestate_python/option/unquote_annotations_option.py

@@ -0,0 +1,85 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from wexample_helpers.decorator.base_class import base_class
+
+from .abstract_python_file_content_option import AbstractPythonFileContentOption
+
+if TYPE_CHECKING:
+    from wexample_filestate.const.types_state_items import TargetFileOrDirectoryType
+
+
+@base_class
+class UnquoteAnnotationsOption(AbstractPythonFileContentOption):
+    def get_description(self) -> str:
+        return "Unquote type annotations (arguments, returns, variables) using LibCST."
+
+    def _apply_content_change(self, target: TargetFileOrDirectoryType) -> str:
+        """Remove quotes around type annotations by turning stringized annotations back into expressions."""
+        import json
+
+        import libcst as cst
+
+        src = target.get_local_file().read()
+
+        class _Unquoter(cst.CSTTransformer):
+            @staticmethod
+            def _unquote_expr(s: cst.SimpleString) -> cst.BaseExpression | None:
+                try:
+                    code = json.loads(s.value)
+                except Exception:
+                    return None
+                try:
+                    return cst.parse_expression(code)
+                except Exception:
+                    return None
+
+            @staticmethod
+            def _process_annotation(
+                ann: cst.Annotation | None,
+            ) -> cst.Annotation | None:
+                if ann is None:
+                    return None
+                node = ann.annotation
+                if isinstance(node, cst.SimpleString):
+                    expr = _Unquoter._unquote_expr(node)
+                    if expr is not None:
+                        return cst.Annotation(annotation=expr)
+                return ann
+
+            def leave_Param(
+                self, original_node: cst.Param, updated_node: cst.Param
+            ) -> cst.Param:
+                return updated_node.with_changes(
+                    annotation=self._process_annotation(updated_node.annotation)
+                )
+
+            def leave_FunctionDef(
+                self, original_node: cst.FunctionDef, updated_node: cst.FunctionDef
+            ) -> cst.FunctionDef:
+                return updated_node.with_changes(
+                    returns=self._process_annotation(updated_node.returns)
+                )
+
+            def leave_AnnAssign(
+                self, original_node: cst.AnnAssign, updated_node: cst.AnnAssign
+            ) -> cst.AnnAssign:
+                return updated_node.with_changes(
+                    annotation=self._process_annotation(updated_node.annotation)
+                )
+
+            def leave_TypeAlias(
+                self, original_node: cst.TypeAlias, updated_node: cst.TypeAlias
+            ) -> cst.TypeAlias:
+                # Python 3.12 'type X = ...' syntax
+                ann = updated_node.annotation
+                if isinstance(ann, cst.SimpleString):
+                    expr = self._unquote_expr(ann)
+                    if expr is not None:
+                        return updated_node.with_changes(annotation=expr)
+                return updated_node
+
+        module = cst.parse_module(src)
+        new_mod = module.visit(_Unquoter())
+        return new_mod.code

wexample_filestate_python/options_provider/python_options_provider.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from wexample_config.options_provider.abstract_options_provider import (
+    AbstractOptionsProvider,
+)
+
+if TYPE_CHECKING:
+    from wexample_config.config_option.abstract_config_option import (
+        AbstractConfigOption,
+    )
+
+
+class PythonOptionsProvider(AbstractOptionsProvider):
+    @classmethod
+    def get_options(cls) -> list[type[AbstractConfigOption]]:
+        from wexample_filestate_python.option.python_option import (
+            PythonOption,
+        )
+
+        return [
+            PythonOption,
+        ]

wexample_filestate_python/utils/python_attrs_utils.py

@@ -0,0 +1,112 @@
+from __future__ import annotations
+
+import libcst as cst
+
+
+def fix_attrs_kw_only(module: cst.Module) -> cst.Module:
+    """Ensure attrs decorators always use kw_only=True.
+
+    This applies to:
+    - @attrs.define
+    - @attr.s
+    - @attrs.frozen
+    """
+
+    class AttrsKwOnlyFixer(cst.CSTTransformer):
+        def leave_Decorator(
+            self, original_node: cst.Decorator, updated_node: cst.Decorator
+        ) -> cst.Decorator:
+            # Check if this is an attrs decorator
+            if not _is_attrs_decorator(updated_node):
+                return updated_node
+
+            # Get the decorator call
+            if isinstance(updated_node.decorator, cst.Call):
+                call = updated_node.decorator
+
+                # Check if kw_only is already present
+                has_kw_only = _has_kw_only_arg(call)
+
+                if not has_kw_only:
+                    # Add kw_only=True to the call
+                    new_args = list(call.args)
+                    kw_only_arg = cst.Arg(
+                        keyword=cst.Name("kw_only"), value=cst.Name("True")
+                    )
+                    new_args.append(kw_only_arg)
+
+                    new_call = call.with_changes(args=new_args)
+                    return updated_node.with_changes(decorator=new_call)
+                else:
+                    # Check if kw_only is set to False and change it to True
+                    new_args = []
+                    for arg in call.args:
+                        if (
+                            isinstance(arg.keyword, cst.Name)
+                            and arg.keyword.value == "kw_only"
+                            and isinstance(arg.value, cst.Name)
+                            and arg.value.value == "False"
+                        ):
+                            # Change False to True
+                            new_arg = arg.with_changes(value=cst.Name("True"))
+                            new_args.append(new_arg)
+                        else:
+                            new_args.append(arg)
+
+                    if new_args != list(call.args):
+                        new_call = call.with_changes(args=new_args)
+                        return updated_node.with_changes(decorator=new_call)
+
+            elif isinstance(updated_node.decorator, (cst.Name, cst.Attribute)):
+                # Decorator without parentheses, add them with kw_only=True
+                kw_only_arg = cst.Arg(
+                    keyword=cst.Name("kw_only"), value=cst.Name("True")
+                )
+
+                new_call = cst.Call(func=updated_node.decorator, args=[kw_only_arg])
+                return updated_node.with_changes(decorator=new_call)
+
+            return updated_node
+
+    transformer = AttrsKwOnlyFixer()
+    modified_module = module.visit(transformer)
+
+    return modified_module
+
+
+def _has_kw_only_arg(call: cst.Call) -> bool:
+    """Check if the call already has a kw_only argument."""
+    for arg in call.args:
+        if isinstance(arg.keyword, cst.Name) and arg.keyword.value == "kw_only":
+            return True
+    return False
+
+
+def _is_attrs_decorator(decorator: cst.Decorator) -> bool:
+    """Check if decorator is an attrs decorator (@attrs.define, @attr.s, etc.)."""
+    # Get the base decorator (without call)
+    base_decorator = decorator.decorator
+    if isinstance(base_decorator, cst.Call):
+        base_decorator = base_decorator.func
+
+    # Check for @attrs.define, @attrs.frozen, etc.
+    if isinstance(base_decorator, cst.Attribute):
+        if (
+            isinstance(base_decorator.value, cst.Name)
+            and base_decorator.value.value == "attrs"
+            and isinstance(base_decorator.attr, cst.Name)
+            and base_decorator.attr.value in ("define", "frozen")
+        ):
+            return True
+
+    # Check for @attr.s
+    if isinstance(base_decorator, cst.Attribute):
+        if (
+            isinstance(base_decorator.value, cst.Name)
+            and base_decorator.value.value == "attr"
+            and isinstance(base_decorator.attr, cst.Name)
+            and base_decorator.attr.value == "s"
+        ):
+            return True
+
+    return False