refine 0.10.0__py3-none-any.whl

refine/__init__.py

@@ -0,0 +1,13 @@
+from __future__ import annotations
+
+import contextlib
+
+try:
+    from refine._version import __version__
+except ImportError:  # pragma: no cover
+    __version__ = "0.0.0.not-installed"
+    from importlib.metadata import PackageNotFoundError
+    from importlib.metadata import version
+
+    with contextlib.suppress(PackageNotFoundError):
+        __version__ = version("re-code")

refine/__main__.py

@@ -0,0 +1,153 @@
+"""
+Utility to simplify rewriting python code.
+
+It can be used for one-off rewrites, or, to maintain code styling rules.
+"""
+
+from __future__ import annotations
+
+import argparse
+import logging
+import pathlib
+import sys
+from multiprocessing import freeze_support
+from typing import NoReturn
+
+from refine import __version__
+from refine.config import Config
+from refine.exc import ReCodeSystemExit
+from refine.processor import Processor
+from refine.registry import Registry
+
+logging.basicConfig(level=logging.INFO, stream=sys.stderr, format="%(message)s")
+
+log = logging.getLogger(__name__)
+
+
+def main() -> NoReturn:  # noqa: PLR0915
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--version", action="version", version=__version__)
+    parser.add_argument("files", metavar="FILE", nargs="*", type=pathlib.Path, help="One or more files to process.")
+    parser.add_argument(
+        "--config",
+        type=pathlib.Path,
+        help="Path to config file. Defaults to '.refine.ini' on the current directory.",
+        default=".refine.toml",
+    )
+    parser.add_argument("--quiet", "-q", action="store_true", default=False, help="Quiet down the tool output.")
+    parser.add_argument(
+        "--fail-fast",
+        "--ff",
+        action="store_true",
+        default=False,
+        help="Exit as soon as possible on the first processing error",
+    )
+    parser.add_argument(
+        "--list-codemods",
+        "--list",
+        action="store_true",
+        help="List all available codemods",
+    )
+    parser.add_argument(
+        "--exclude-codemod",
+        "--exclude",
+        default=[],
+        action="append",
+        help="Exclude codemods from available codemods.",
+    )
+    parser.add_argument(
+        "--select-codemod",
+        "--select",
+        default=[],
+        action="append",
+        help="Explicitly select codemod names from available codemods.",
+    )
+    parser.add_argument(
+        "--codemods-path",
+        type=pathlib.Path,
+        action="append",
+        default=[],
+        dest="codemods_paths",
+        help="Path to a codemods directory. Can be passed multiple times.",
+    )
+    args = parser.parse_args()
+    if args.quiet:
+        logging.getLogger().setLevel(logging.ERROR)
+    if not args.config.is_absolute():
+        config_file = pathlib.Path.cwd().joinpath(args.config).resolve()
+    else:
+        config_file = args.config
+    if config_file.exists():
+        if config_file.name == "pyproject.toml":
+            config = Config.from_pyproject_file(config_file)
+        else:
+            config = Config.from_default_file(config_file)
+    elif pathlib.Path.cwd().joinpath("pyproject.toml").exists():
+        config = Config.from_pyproject_file(pathlib.Path.cwd().joinpath("pyproject.toml"))
+    else:
+        config = Config()
+
+    if args.list_codemods:
+        # Add the additional CLI passed codemod paths
+        config.codemod_paths[:] = list(set(config.codemod_paths) | set(args.codemods_paths))
+
+    if args.select_codemod:
+        # Add any additional CLI passed selections
+        config.select[:] = list(set(config.select) | set(args.select_codemod))
+
+    if args.exclude_codemod:
+        # Add any additional CLI passed exclusions
+        config.exclude[:] = list(set(config.exclude) | set(args.exclude_codemod))
+
+    if args.fail_fast:
+        config = config.model_copy(update={"fail_fast": True}, deep=True)
+
+    registry = Registry()
+    registry.load(config.codemod_paths)
+    if args.list_codemods:
+        log.info("Available codemods:")
+        for codemod in registry.codemods():
+            # In case the description is comming from the docstring, we just really want the first line.
+            description = codemod.DESCRIPTION.strip().splitlines()[0]
+            log.info(" - %s: %s", codemod.NAME, description.strip())
+        parser.exit()
+
+    paths = args.files
+    if not paths:
+        paths = config.repo_root.glob("**/*.py")
+
+    files: list[pathlib.Path] = []
+    for path in paths:
+        if path.is_file():
+            files.append(path)
+            continue
+        for subpath in path.rglob("*.py"):
+            files.append(subpath)
+
+    codemods = list(registry.codemods(select_codemods=config.select, exclude_codemods=config.exclude))
+    log.info("Selected codemods:")
+    for codemod in codemods:
+        log.info(" - %s: %s", codemod.NAME, codemod.DESCRIPTION)
+
+    processor = Processor(config=config, registry=registry, codemods=codemods)
+    try:
+        result = processor.process(files)
+        if result.failures:
+            parser.exit(status=1)
+    except ReCodeSystemExit as exc:
+        parser.exit(status=exc.code, message=exc.message)
+    except SystemExit as exc:
+        code: str | int | None = exc.code
+        if code is None:
+            parser.exit(status=1)
+        if isinstance(code, int):
+            parser.exit(status=code)
+        parser.exit(status=1, message=code)
+    except KeyboardInterrupt:
+        parser.exit(status=1)
+    parser.exit(status=0)
+
+
+if __name__ == "__main__":
+    freeze_support()
+    main()

refine/_version.py

@@ -0,0 +1,3 @@
+# Version attribute defined and written at build time
+
+__version__ = "0.10.0"

refine/_version.pyi

@@ -0,0 +1 @@
+__version__: str

refine/abc.py

@@ -0,0 +1,68 @@
+"""
+Abstract base classes for defining codemod types and their configurations.
+"""
+
+from __future__ import annotations
+
+from abc import ABC
+from typing import TYPE_CHECKING
+from typing import ClassVar
+from typing import Generic
+from typing import TypeVar
+
+from libcst.codemod import CodemodContext
+from libcst.codemod import VisitorBasedCodemodCommand
+from pydantic import BaseModel
+from pydantic import ConfigDict
+
+
+class BaseConfig(BaseModel):
+    """
+    Base configuration class for codemoders.
+    """
+
+    model_config = ConfigDict(frozen=True)
+
+
+CodemodConfigType = TypeVar("CodemodConfigType", bound=BaseConfig)
+
+
+class BaseCodemod(VisitorBasedCodemodCommand, ABC, Generic[CodemodConfigType]):
+    """
+    Base class for codemoders.
+    """
+
+    NAME: ClassVar[str]
+    CONFIG_CLS: ClassVar[type[BaseConfig]]
+    PRIORITY: ClassVar[int] = 0
+
+    def __init__(self, context: CodemodContext, config: CodemodConfigType):
+        super().__init__(context)
+        self.config = config
+        self.__post_codemod_init__()
+
+    def __post_codemod_init__(self) -> None:
+        """
+        This method can implement additional codemod initialization.
+        """
+
+    @classmethod
+    def get_short_description(cls) -> str:
+        """
+        Return a short description of the codemod.
+
+        This short description is used in the CLI to list available codemods and should be a single line.
+
+        By default, it returns the first line of the class docstring, override this method to provide a
+        custom description.
+        """
+        doc = cls.__doc__
+        if cls is None:
+            error_msg = f"Codemod {cls.__name__} must have a docstring to be used in the CLI."
+            raise TypeError(error_msg)
+        if TYPE_CHECKING:
+            assert doc is not None
+        return doc.strip().splitlines()[0].strip()
+
+
+CodemodType = TypeVar("CodemodType", bound=BaseCodemod)

refine/config.py

@@ -0,0 +1,152 @@
+"""
+re:Code configuration.
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+import tomllib
+from pathlib import Path
+from typing import Any
+
+from pydantic import BaseModel
+from pydantic import ConfigDict
+from pydantic import Field
+
+log = logging.getLogger(__name__)
+
+
+def _cpu_count() -> int:
+    # os.cpu_count() can return None, let's not.
+    return os.cpu_count() or 1
+
+
+class ConfigError(ValueError):
+    """
+    Config related error.
+    """
+
+
+class ConfigLoadError(ConfigError):
+    """
+    Exception raised when failing to load the configuration from file.
+    """
+
+
+class InvalidConfigError(ConfigError):
+    """
+    Exception raised when the loaded configuration is not valid.
+    """
+
+
+class Config(BaseModel):
+    """
+    Main codemod configuration schema.
+    """
+
+    model_config = ConfigDict(
+        # Don't allow the config object to be mutable.
+        # Do note that mutable objects(set, list, dict) of the immutable config class remain mutable.
+        frozen=True,
+        # Allow extra keys, these will be codemods configs
+        extra="allow",
+    )
+
+    select: list[str] = Field(
+        default_factory=list,
+        description="""
+        List of codemods to run.
+
+        When no selection is made, all available codemods are run.
+        """,
+    )
+    exclude: list[str] = Field(
+        default_factory=list,
+        description="""
+        List of codemods to exclude.
+
+        Only makes sense when `select` is empty and all codemods are run.
+    """,
+    )
+    codemod_paths: list[Path] = Field(
+        default_factory=list,
+        description="""
+        List of additional paths to search for codemods.
+        """,
+    )
+    process_pool_size: int = Field(
+        default_factory=_cpu_count,
+        description="""
+        Number of processes to use for parallel processing.
+        Defaults to the number of available CPUs.
+        """,
+    )
+    repo_root: Path = Field(
+        default_factory=Path.cwd,
+        description="""
+        The root directory of the repository.
+        Defaults to the current working directory.
+        """,
+    )
+    fail_fast: bool = Field(
+        default=False,
+        description="""
+        Stop processing as soon as possible after the first error.
+        """,
+    )
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> Config:
+        """
+        Load the configuration from a dictionary.
+
+        Arguments:
+            data: The configuration to load.
+
+        Returns:
+            Config instance.
+        """
+        try:
+            return Config(**data)
+        except ValueError as exc:
+            error = f"Invalid configuration: {exc}"
+            raise InvalidConfigError(error) from exc
+
+    @classmethod
+    def from_default_file(cls, path: Path) -> Config:
+        """
+        Load the configuration from a file.
+
+        Arguments:
+            path: The path to the configuration file.
+
+        Returns:
+            Config instance.
+        """
+        try:
+            data = tomllib.loads(path.read_text(encoding="utf-8"))
+        except tomllib.TOMLDecodeError as exc:
+            error = f"Unable to parse {path}: {exc}"
+            raise ConfigLoadError(error) from exc
+        else:
+            return cls.from_dict(data)
+
+    @classmethod
+    def from_pyproject_file(cls, path: Path) -> Config:
+        """
+        Load the configuration from a file.
+
+        Arguments:
+            path: The path to the configuration file.
+
+        Returns:
+            Config instance.
+        """
+        try:
+            data = tomllib.loads(path.read_text(encoding="utf-8"))
+        except tomllib.TOMLDecodeError as exc:
+            error = f"Unable to parse {path}: {exc}"
+            raise ConfigLoadError(error) from exc
+        else:
+            return cls.from_dict(data.get("tool", {}).get("refine", {}))

refine/exc.py

@@ -0,0 +1,29 @@
+"""
+re:Code related exceptions.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+
+class ReCodeError(Exception):
+    """
+    re:Code specific exception.
+    """
+
+
+class ReCodeSystemExit(SystemExit):
+    """
+    re:Code system exit exception that accepts a message argument.
+    """
+
+    code: int
+    message: str | None
+
+    def __init__(self, code: int, message: str | None = None):
+        if TYPE_CHECKING:
+            assert code is not None
+            assert isinstance(code, int)
+        super().__init__(code)
+        self.message = message

refine/mods/cli/flags.py

@@ -0,0 +1,142 @@
+"""
+This codemod enforces the use of dashes over underscores in CLI arguments of [ArgumentParser][argparse.ArgumentParser].
+
+For example, it will transform this code:
+```python
+parser.add_argument("--a_command")
+```
+into this code:
+```python
+parser.add_argument("--a-command")
+```
+"""
+
+from __future__ import annotations
+
+import logging
+import pathlib
+from ast import literal_eval
+from typing import TYPE_CHECKING
+from typing import cast
+
+import libcst as cst
+import libcst.matchers as m
+from libcst.codemod import SkipFile
+
+from refine.abc import BaseCodemod
+from refine.abc import BaseConfig
+
+log = logging.getLogger(__name__)
+
+
+class CliDashesConfig(BaseConfig):
+    django_base_command_package: str = "django.core.management"
+    django_base_command_class_name: str = "BaseCommand"
+
+
+class CliDashes(BaseCodemod):
+    """
+    Replace `_` with `-`, ie, `--a-command` instead of `--a_command` in CLI commands.
+
+    This works if the parser argument is typed and only for ArgumentParser. `def foo(parser: ArgumentParser)`.
+    """
+
+    NAME = "cli-dashes-over-underscores"
+    CONFIG_CLS = CliDashesConfig
+
+    def __post_codemod_init__(self) -> None:
+        """
+        Additional class setup.
+        """
+        self.typed_parameters: dict[str, str] = {}
+        self.typed_assignments: dict[str, str] = {}
+
+    def visit_Module(self, mod: cst.Module) -> bool:
+        filename: str | None = self.context.filename
+        if TYPE_CHECKING:
+            assert filename is not None
+        if pathlib.Path(filename).name.startswith("test_"):
+            skip_reason = "Not touching test files"
+            raise SkipFile(skip_reason)
+        return True
+
+    def visit_FunctionDef(self, node: cst.FunctionDef) -> None:
+        # Collect type annotations of parameters
+        self.typed_parameters = {}
+        for param in node.params.params:
+            if param.annotation:
+                param_name = param.name.value
+                annotation = param.annotation.annotation
+                if isinstance(annotation, cst.Name) and annotation.value == "ArgumentParser":
+                    self.typed_parameters[param_name] = annotation.value
+
+    def leave_FunctionDef(self, original: cst.FunctionDef, updated: cst.FunctionDef) -> cst.FunctionDef:
+        # Clear state when leaving the function
+        self.typed_parameters = {}
+        self.typed_assignments = {}
+        return updated
+
+    def visit_AnnAssign(self, node: cst.AnnAssign) -> None:
+        if isinstance(node.target, cst.Name):
+            var_name = node.target.value
+            annotation = node.annotation.annotation
+            if isinstance(annotation, cst.Name) and annotation.value == "ArgumentParser":
+                self.typed_assignments[var_name] = annotation.value
+
+    def visit_Assign(self, node: cst.Assign) -> None:
+        # NOTE: we're not taking into account import aliases
+        assign_target: cst.AssignTarget
+        for assign_target in node.targets:
+            if not isinstance(assign_target.target, cst.Name):
+                # We only want to handle simple assignments:
+                # var_a = value_a
+                # We're not handling assignment expansion, ie
+                # var_a, var_b = value_a, value_b
+                continue
+            target: cst.Name = cast("cst.Name", assign_target.target)
+            var_name = target.value
+            if m.matches(
+                node.value,
+                m.OneOf(
+                    # blah = ArgumentParser
+                    m.Call(func=m.Name("ArgumentParser")),
+                    # blah = argparse.ArgumentParser
+                    m.Call(func=m.Attribute(value=m.Name("argparse"), attr=m.Name("ArgumentParser"))),
+                ),
+            ):
+                self.typed_assignments[var_name] = "ArgumentParser"
+
+    def leave_Call(self, original: cst.Call, updated: cst.Call) -> cst.Call:
+        # Check for `<something>.add_argument(...)` calls
+        if m.matches(
+            original.func,
+            m.Attribute(attr=m.Name("add_argument"), value=m.Name()),
+        ):
+            # The `<something>` in `<something>.add_argument`
+            caller_func_attribute = cast("cst.Attribute", original.func)
+            caller_func_attribute_name = cast("cst.Name", caller_func_attribute.value)
+            caller_name = caller_func_attribute_name.value
+
+            # Verify if the caller object is typed as ArgumentParser
+            if caller_name not in self.typed_parameters and caller_name not in self.typed_assignments:
+                return updated
+
+            args: list[cst.Arg] = []
+            for arg in updated.args:
+                if not isinstance(arg.value, cst.SimpleString):
+                    args.append(arg)
+                    continue
+                simple_string = arg.value
+                flag = literal_eval(simple_string.value)
+                if not flag.startswith("--"):
+                    args.append(arg)
+                    continue
+                if "_" not in flag:
+                    args.append(arg)
+                    continue
+                updated_flag_value = f"{simple_string.quote}{flag.replace('_', '-')}{simple_string.quote}"
+                updated_simple_string = simple_string.with_changes(value=updated_flag_value)
+                updated_arg = arg.with_changes(value=updated_simple_string)
+                args.append(updated_arg)
+            return updated.with_changes(args=args)
+        return updated

refine/mods/sql/.sqlfluff

@@ -0,0 +1,45 @@
+[sqlfluff]
+dialect = mysql
+templater = placeholder
+max_line_length = 120
+processes = -1
+
+[sqlfluff:templater:placeholder]
+param_style = pyformat
+
+[sqlfluff:indentation]
+allow_implicit_indents = True
+indented_joins = True
+tab_space_size = 4
+indent_unit = space
+
+[sqlfluff:rules:aliasing.length]
+min_alias_length = 3
+
+# The default configuration for capitalisation rules is "consistent"
+# which will auto-detect the setting from the rest of the file. This
+# is less desirable in a new project and you may find this (slightly
+# more strict) setting more useful.
+# Typically we find users rely on syntax highlighting rather than
+# capitalisation to distinguish between keywords and identifiers.
+# Clearly, if your organisation has already settled on uppercase
+# formatting for any of these syntax elements then set them to "upper".
+# See https://stackoverflow.com/questions/608196/why-should-i-capitalize-my-sql-keywords-is-there-a-good-reason
+[sqlfluff:rules:capitalisation.keywords]
+capitalisation_policy = lower
+[sqlfluff:rules:capitalisation.identifiers]
+extended_capitalisation_policy = lower
+[sqlfluff:rules:capitalisation.functions]
+extended_capitalisation_policy = lower
+[sqlfluff:rules:capitalisation.literals]
+capitalisation_policy = lower
+[sqlfluff:rules:capitalisation.types]
+extended_capitalisation_policy = lower
+
+# The default configuration for the not equal convention rule is "consistent"
+# which will auto-detect the setting from the rest of the file. This
+# is less desirable in a new project and you may find this (slightly
+# more strict) setting more useful.
+[sqlfluff:rules:convention.not_equal]
+# Default to preferring the "c_style" (i.e. `!=`)
+preferred_not_equal_style = c_style