codesorter 0.1.0__py3-none-any.whl

codesorter/__init__.py

@@ -0,0 +1,5 @@
+"""CodeSorter is a codemod that sorts Python code in a project."""
+
+from codesorter.cli import main
+
+__all__ = ["main"]

codesorter/cli.py

@@ -0,0 +1,227 @@
+"""Command-line interface for the code sorter tool."""
+
+from __future__ import annotations
+
+import argparse
+import sys
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+import libcst as cst
+import libcst.tool
+import pathspec
+from libcst.codemod import CodemodContext
+
+from codesorter.const import DEFAULT_EXCLUDES
+from codesorter.sort_code import SortCodeCommand
+
+if TYPE_CHECKING:
+    from pathspec.pattern import Pattern
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    """Build the argument parser for the code sorter CLI."""
+    parser = argparse.ArgumentParser(
+        prog="codesorter",
+        description=(
+            "Sort Python code in the specified package or file. This tool analyzes "
+            "Python code and sorts classes and functions based on their dependencies "
+            "and relationships."
+        ),
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+    )
+    parser.add_argument(
+        "-c",
+        "--check",
+        action="store_true",
+        help="Don't write files; exit non-zero if any file would be reordered.",
+    )
+    parser.add_argument(
+        "-j",
+        "--jobs",
+        type=int,
+        help="Number of jobs to use when processing files.",
+    )
+    parser.add_argument(
+        "-s",
+        "--show-successes",
+        action="store_true",
+        help="Print files successfully sorted with no warnings.",
+    )
+    parser.add_argument(
+        "-u",
+        "--unified-diff",
+        action="store_true",
+        help="Output unified diff instead of contents.",
+    )
+    parser.add_argument(
+        "-e",
+        "--exclude",
+        dest="extra_excludes",
+        action="append",
+        default=[],
+        metavar="NAME",
+        help="Directory name to skip when walking paths. May be passed multiple times.",
+    )
+    parser.add_argument(
+        "--no-default-excludes",
+        action="store_true",
+        help="Disable the built-in directory excludes (.git, .venv, __pycache__, build, dist, ...).",
+    )
+    parser.add_argument(
+        "--no-gitignore",
+        action="store_true",
+        help="Do not honor .gitignore files when walking paths.",
+    )
+    parser.add_argument(
+        "paths",
+        nargs="*",
+        help="Files or directories to sort. Defaults to the current directory.",
+    )
+    return parser
+
+
+def _check_files(*, files: list[str]) -> int:
+    """Run the sort codemod in-process and report files that would change."""
+    changed: list[str] = []
+    failed: list[str] = []
+    for path in files:
+        try:
+            source = Path(path).read_text(encoding="utf-8")
+        except OSError as exc:
+            sys.stderr.write(f"{path}: read error: {exc}\n")
+            failed.append(path)
+            continue
+        try:
+            new_tree = SortCodeCommand(CodemodContext()).transform_module(cst.parse_module(source))
+        except Exception as exc:  # noqa: BLE001
+            sys.stderr.write(f"{path}: transform error: {exc}\n")
+            failed.append(path)
+            continue
+        if new_tree.code != source:
+            changed.append(path)
+            sys.stderr.write(f"Would reorder: {path}\n")
+    if changed or failed:
+        sys.stderr.write(
+            f"{len(changed)} file(s) would be reordered, {len(failed)} file(s) failed.\n",
+        )
+        return 1
+    return 0
+
+
+def _collect_files(
+    *,
+    excludes: set[str],
+    honor_gitignore: bool,
+    parser: argparse.ArgumentParser,
+    paths: tuple[str, ...],
+) -> list[str]:
+    """Expand the given paths into a sorted, de-duplicated list of .py files."""
+    seen: set[Path] = set()
+    files: list[str] = []
+    for raw in paths:
+        path = Path(raw)
+        if not path.exists():
+            parser.error(f"Path not found: {raw}")
+        if path.is_file():
+            resolved = path.resolve()
+            if resolved not in seen:
+                seen.add(resolved)
+                files.append(str(path))
+            continue
+
+        ignore_specs = _load_gitignore_specs(root=path, excludes=excludes) if honor_gitignore else []
+
+        for candidate in sorted(path.rglob("*.py")):
+            relative_parts = candidate.relative_to(path).parts
+            if any(part in excludes for part in relative_parts):
+                continue
+            if _matches_gitignore(candidate=candidate, specs=ignore_specs):
+                continue
+            resolved = candidate.resolve()
+            if resolved in seen:
+                continue
+            seen.add(resolved)
+            files.append(str(candidate))
+    return files
+
+
+def _load_gitignore_specs(
+    *,
+    root: Path,
+    excludes: set[str],
+) -> list[tuple[Path, pathspec.PathSpec[Pattern]]]:
+    """Collect (anchor_dir, spec) for every .gitignore at or below root.
+
+    Each spec is interpreted relative to its containing directory, matching git's own
+    behavior with nested .gitignore files.
+
+    """
+    specs: list[tuple[Path, pathspec.PathSpec[Pattern]]] = []
+    for gitignore in root.rglob(".gitignore"):
+        if not gitignore.is_file():
+            continue
+        if any(part in excludes for part in gitignore.relative_to(root).parts):
+            continue
+        lines = gitignore.read_text(encoding="utf-8", errors="replace").splitlines()
+        spec = pathspec.PathSpec.from_lines("gitwildmatch", lines)
+        specs.append((gitignore.parent, spec))
+    return specs
+
+
+def _matches_gitignore(
+    *,
+    candidate: Path,
+    specs: list[tuple[Path, pathspec.PathSpec[Pattern]]],
+) -> bool:
+    """Return True if any covering .gitignore matches the candidate file."""
+    for anchor, spec in specs:
+        try:
+            rel = candidate.relative_to(anchor)
+        except ValueError:
+            continue
+        if spec.match_file(str(rel)):
+            return True
+    return False
+
+
+def main(*, argv: list[str] | None = None) -> None:
+    """Sort Python code in the specified package or file."""
+    parser = _build_parser()
+    args = parser.parse_args(argv)
+
+    paths: tuple[str, ...] = tuple(args.paths) or (".",)
+
+    excludes = set(args.extra_excludes)
+    if not args.no_default_excludes:
+        excludes.update(DEFAULT_EXCLUDES)
+
+    files = _collect_files(
+        excludes=excludes,
+        honor_gitignore=not args.no_gitignore,
+        parser=parser,
+        paths=paths,
+    )
+    if not files:
+        parser.error("No Python files to sort.")
+
+    if args.check:
+        sys.exit(_check_files(files=files))
+
+    cst_argv = [
+        "codemod",
+        "-x",
+        "codesorter.sort_code.SortCodeCommand",
+        *files,
+    ]
+
+    if args.unified_diff:
+        cst_argv.append("--unified-diff")
+
+    if args.show_successes:
+        cst_argv.append("--show-successes")
+
+    if args.jobs is not None:
+        cst_argv.extend(["--jobs", str(args.jobs)])
+
+    sys.exit(libcst.tool.main("codesorter", cst_argv))

codesorter/const.py

@@ -0,0 +1,25 @@
+"""Package constants and version metadata."""
+
+__version__ = "0.1.0"
+
+DEFAULT_EXCLUDES: tuple[str, ...] = (
+    ".bzr",
+    ".direnv",
+    ".eggs",
+    ".git",
+    ".hg",
+    ".mypy_cache",
+    ".nox",
+    ".pytest_cache",
+    ".ruff_cache",
+    ".svn",
+    ".tox",
+    ".venv",
+    "__pycache__",
+    "__pypackages__",
+    "build",
+    "dist",
+    "env",
+    "node_modules",
+    "venv",
+)

codesorter/sort_code.py

@@ -0,0 +1,334 @@
+"""The SortCodeCommand libcst codemod that reorders classes, methods, and functions."""
+
+from __future__ import annotations
+
+import enum
+from collections import defaultdict
+from enum import auto
+
+import libcst as cst
+from libcst import matchers as m
+from libcst import metadata as md
+from libcst.codemod import CodemodContext, VisitorBasedCodemodCommand
+
+_PROPERTY_DECORATOR_PARTS = 2
+_PLAIN_DECORATOR_PARTS = 1
+
+
+def _gen_unique_name(node: cst.ClassDef | cst.FunctionDef) -> str:
+    parts = [node.name.value]
+    if isinstance(node, cst.ClassDef):
+        items: tuple[cst.CSTNode, ...] = (*node.bases, *node.decorators, *node.keywords)
+    else:
+        items = (node,)
+    for item in items:
+        parts.extend(cst.ensure_type(name, cst.Name).value for name in m.findall(item, m.Name()))
+    return ".".join(parts)
+
+
+class DependencyType(enum.IntEnum):
+    """Ordering buckets used to keep dependents after their dependencies."""
+
+    not_required = auto()
+    required = auto()
+
+
+class FixtureType(enum.IntEnum):
+    """Pytest fixture scopes used as a secondary sort key for fixture methods."""
+
+    na = 0
+    session_fixture = auto()
+    package_fixture = auto()
+    module_fixture = auto()
+    class_fixture = auto()
+    function_fixture = auto()
+
+
+class MethodType(enum.IntEnum):
+    """Method kinds used to sort methods within a class body."""
+
+    na = 0
+    abstractmethod = auto()
+    autouse_fixture = auto()
+    fixture = auto()
+    staticmethod = auto()
+    classmethod = auto()
+    cachedproperty = auto()
+    property = auto()
+    contextmanager = auto()
+    instance = auto()
+
+
+class PropertyType(enum.IntEnum):
+    """Property accessor kinds used to group getter/setter/deleter together."""
+
+    na = 0
+    getter = auto()
+    setter = auto()
+    deleter = auto()
+
+
+class SortingTransformer(cst.CSTTransformer):
+    """Apply a precomputed replacements map to swap nodes during a traversal."""
+
+    def __init__(self, replacements: dict[str, cst.ClassDef | cst.FunctionDef]) -> None:
+        """Store the replacements keyed by unique node name."""
+        self.replacements = replacements
+        super().__init__()
+
+    def on_leave(
+        self,
+        original_node: cst.CSTNode,
+        updated_node: cst.CSTNode,
+    ) -> cst.CSTNode:
+        """Swap matching class or function nodes for their replacement."""
+        if isinstance(original_node, (cst.ClassDef, cst.FunctionDef)):
+            return self.replacements.get(_gen_unique_name(original_node), updated_node)
+        return updated_node
+
+
+class SortCodeCommand(VisitorBasedCodemodCommand, m.MatcherDecoratableTransformer):
+    """Reorder module- and class-level definitions based on their dependencies."""
+
+    # Add a description so that future codemodders can see what this does.
+    DESCRIPTION: str = "Sorts code in project"
+
+    METADATA_DEPENDENCIES = (md.ScopeProvider,)
+
+    @property
+    def in_class(self) -> bool:
+        """Return True while the visitor is inside a class body."""
+        return bool(self._class_depth)
+
+    @in_class.setter
+    def in_class(self, value: bool) -> None:
+        if value:
+            self._class_depth += 1
+        elif self._class_depth > 0:
+            self._class_depth -= 1
+        else:
+            self._class_depth = 0
+
+    def __init__(self, context: CodemodContext) -> None:
+        """Initialize per-run state used while collecting and sorting nodes."""
+        super().__init__(context)
+        self._counter = 0
+        self._class_depth = 0
+        self.original_nodes: dict[str, cst.CSTNode] = {}
+        self.dependencies: defaultdict[str, set[str]] = defaultdict(set)
+        self.dependents: defaultdict[str, set[str]] = defaultdict(set)
+
+    def _get_dependencies(  # noqa: C901
+        self,
+        node: cst.ClassDef | cst.FunctionDef,
+    ) -> tuple[list[str], md.Scope]:
+        original = self.original_nodes.get(_gen_unique_name(node))
+        meta = None if original is None else self.get_metadata(md.ScopeProvider, original, None)
+        if meta is None:
+            msg = f"missing scope metadata for {node.name.value!r}"
+            raise ValueError(msg)
+        dependencies: set[str] = set()
+        if isinstance(meta, (md.ClassScope, md.GlobalScope)):
+
+            def _outer_scope(scope: object) -> bool:
+                return isinstance(scope, (md.ClassScope, md.GlobalScope)) or (
+                    isinstance(scope, md.ClassScope) and scope.parent != meta
+                )
+
+            for found in self.extractall(
+                node,
+                m.SaveMatchedNode(
+                    m.Name(
+                        value=m.DoesNotMatch(node.name.value),
+                        metadata=m.MatchMetadataIfTrue(md.ScopeProvider, _outer_scope),
+                    ),
+                    "name",
+                ),
+            ):
+                try:
+                    node_name = cst.ensure_type(found["name"], cst.Name).value
+                    is_import = isinstance(
+                        next(iter(meta.assignments[node_name])),
+                        md.ImportAssignment,
+                    )
+                    if is_import:
+                        continue
+                    is_global_scope = False
+                    for access in meta[node_name]:
+                        if isinstance(access, md.Access) and access.is_annotation:
+                            continue
+                        if isinstance(access.scope, md.GlobalScope):
+                            is_global_scope = True
+                            break
+                        if isinstance(access.scope, md.ClassScope):
+                            if access.scope.node == node:
+                                continue
+                            is_global_scope = True
+                            break
+                    if is_global_scope:
+                        dependencies.add(node_name)
+                except StopIteration:
+                    pass
+            if self.matches(node, m.ClassDef()):
+                for subclass in self.extractall(
+                    node,
+                    m.ClassDef(
+                        bases=[
+                            m.Arg(
+                                value=m.SaveMatchedNode(
+                                    m.Name(
+                                        value=m.DoesNotMatch(node.name.value),
+                                    ),
+                                    "name",
+                                )
+                            ),
+                        ]
+                    ),
+                ):
+                    subclass_name = cst.ensure_type(subclass["name"], cst.Name).value
+                    for assignment in meta.globals.assignments[subclass_name]:
+                        if isinstance(assignment, (md.BuiltinAssignment, md.ImportAssignment)):
+                            continue
+                        dependencies.add(subclass_name)
+        return list(dependencies), meta
+
+    def _get_replacements(
+        self,
+        items: list[cst.ClassDef | cst.FunctionDef],
+    ) -> dict[str, cst.ClassDef | cst.FunctionDef]:
+        return {
+            _gen_unique_name(old): new for old, new in zip(items, sorted(items, key=self._node_sort_key), strict=True)
+        }
+
+    def _node_sort_key(
+        self,
+        node: cst.ClassDef | cst.FunctionDef,
+    ) -> tuple[list[DependencyType], bool, MethodType, FixtureType, str, PropertyType]:
+        _, meta = self._get_dependencies(node)
+        is_class = self.matches(node, m.ClassDef())
+        method_type = MethodType.na
+        fixture_type = FixtureType.na
+        node_name = node.name.value
+        property_type = PropertyType.na
+        if not is_class:
+            method_type = MethodType.instance
+            for outer_decorator in node.decorators:
+                decorator = outer_decorator.decorator
+                decorator_parts = [cst.ensure_type(part, cst.Name).value for part in self.findall(decorator, m.Name())]
+                if len(decorator_parts) == _PROPERTY_DECORATOR_PARTS:
+                    decorator_type, accessor = decorator_parts
+                    if decorator_type == node.name.value:
+                        method_type = MethodType.property
+                        property_type = PropertyType[accessor]
+                if len(decorator_parts) == _PLAIN_DECORATOR_PARTS:
+                    decorator_type = decorator_parts[0]
+                    if decorator_type == "property":
+                        method_type = MethodType.property
+                        property_type = PropertyType.getter
+                    else:
+                        method_type = MethodType.__members__.get(decorator_type, method_type)
+                if self.matches(
+                    decorator,
+                    m.Attribute(attr=m.Name(value="fixture"), value=m.Name("pytest"))
+                    | m.Call(func=m.Attribute(attr=m.Name(value="fixture"), value=m.Name("pytest"))),
+                ):
+                    scope_match = self.extract(
+                        decorator,
+                        m.Call(
+                            args=[
+                                m.ZeroOrMore(m.DoNotCare()),
+                                m.OneOf(
+                                    m.Arg(
+                                        keyword=m.Name(value="scope"),
+                                        value=m.SaveMatchedNode(m.SimpleString(), "scope"),
+                                    )
+                                ),
+                                m.ZeroOrMore(m.DoNotCare()),
+                            ]
+                        ),
+                    )
+                    autouse = self.matches(
+                        decorator,
+                        m.Call(
+                            args=[
+                                m.ZeroOrMore(m.DoNotCare()),
+                                m.OneOf(
+                                    m.Arg(
+                                        keyword=m.Name(value="autouse"),
+                                        value=m.Name("True"),
+                                    )
+                                ),
+                                m.ZeroOrMore(m.DoNotCare()),
+                            ]
+                        ),
+                    )
+                    fixture_type = FixtureType.function_fixture
+                    if scope_match:
+                        scope_value = cst.ensure_type(scope_match["scope"], cst.SimpleString).evaluated_value
+                        fixture_type = FixtureType[f"{scope_value}_fixture"]
+                    method_type = MethodType.autouse_fixture if autouse else MethodType.fixture
+                elif isinstance(decorator, cst.Attribute) and isinstance(decorator.value, cst.Name):
+                    method_type = MethodType.__members__.get(decorator.value.value, method_type)
+        return (
+            [
+                DependencyType.required
+                if item.name in self.dependencies[node.name.value]
+                else DependencyType.not_required
+                for item in (
+                    meta.assignments if not is_class and isinstance(meta, md.ClassScope) else meta.globals.assignments
+                )
+            ],
+            not is_class if self.in_class else is_class,
+            method_type,
+            fixture_type,
+            node_name,
+            property_type,
+        )
+
+    def _resolve_dependents(self, node: cst.ClassDef | cst.FunctionDef) -> None:
+        dependencies, _ = self._get_dependencies(node)
+        for dependency in dependencies:
+            self.dependencies[node.name.value].add(dependency)
+            for parent_dependency in self.dependencies[dependency]:
+                self.dependencies[node.name.value].add(parent_dependency)
+
+    def leave_ClassDef(
+        self,
+        original_node: cst.ClassDef,
+        updated_node: cst.ClassDef,
+    ) -> cst.ClassDef:
+        """Sort the methods of the class body before returning the rewritten node."""
+        items = [item for item in updated_node.body.body if isinstance(item, (cst.ClassDef, cst.FunctionDef))]
+        updated_node = cst.ensure_type(
+            updated_node.visit(SortingTransformer(self._get_replacements(items))), cst.ClassDef
+        )
+        self.in_class = False
+        return updated_node
+
+    def leave_Module(
+        self,
+        original_node: cst.Module,
+        updated_node: cst.Module,
+    ) -> cst.Module:
+        """Sort the module-level definitions before returning the rewritten module."""
+        items = [item for item in updated_node.body if isinstance(item, (cst.ClassDef, cst.FunctionDef))]
+        updated_node = cst.ensure_type(
+            updated_node.visit(SortingTransformer(self._get_replacements(items))), cst.Module
+        )
+        self.original_nodes = {}
+        return updated_node
+
+    def visit_ClassDef(self, node: cst.ClassDef) -> bool:
+        """Record the class node and its dependencies before descending into it."""
+        unique_name = _gen_unique_name(node)
+        self.original_nodes[unique_name] = node
+        self._resolve_dependents(node)
+        self.in_class = True
+        return True
+
+    def visit_FunctionDef(self, node: cst.FunctionDef) -> bool:
+        """Record the function node and skip descending into its body."""
+        unique_name = _gen_unique_name(node)
+        self.original_nodes[unique_name] = node
+        self._resolve_dependents(node)
+        return False

codesorter-0.1.0.dist-info/METADATA

@@ -0,0 +1,323 @@
+Metadata-Version: 2.4
+Name: codesorter
+Version: 0.1.0
+Summary: A Python codemod that sorts and organizes code in your files.
+Project-URL: Change Log, https://codesorter.readthedocs.io/en/latest/package_info/change_log.html
+Project-URL: Documentation, https://codesorter.readthedocs.io/
+Project-URL: Issue Tracker, https://github.com/praw-dev/CodeSorter/issues
+Project-URL: Source Code, https://github.com/praw-dev/CodeSorter
+Author-email: Joel Payne <lilspazjoekp@gmail.com>
+Maintainer-email: Joel Payne <lilspazjoekp@gmail.com>, Bryce Boe <bbzbryce@gmail.com>
+License: Copyright (c) 2022, Joel Payne
+        All rights reserved.
+        
+        Redistribution and use in source and binary forms, with or without
+        modification, are permitted provided that the following conditions are met:
+        
+        1. Redistributions of source code must retain the above copyright notice, this
+           list of conditions and the following disclaimer.
+        2. Redistributions in binary form must reproduce the above copyright notice,
+           this list of conditions and the following disclaimer in the documentation
+           and/or other materials provided with the distribution.
+        
+        THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+        ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+        WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+        DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+        FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+        DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+        SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+        CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+        OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+        OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+License-File: LICENSE.txt
+Keywords: codemod,codesorter,libcst,sort
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Software Development :: Code Generators
+Classifier: Topic :: Software Development :: Quality Assurance
+Classifier: Topic :: Utilities
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Requires-Dist: libcst<2.0.0,>=1.8.6
+Requires-Dist: pathspec>=1.1.1
+Description-Content-Type: text/x-rst
+
+############
+ CodeSorter
+############
+
+CodeSorter is a LibCST codemod that automatically sorts and organizes Python code.
+
+**********
+ Features
+**********
+
+- **Smart Sorting**: Automatically sorts functions, classes, and methods alphabetically
+- **Decorator Awareness**: Properly handles ``@property``, ``@staticmethod``,
+  ``@classmethod``, and ``@pytest.fixture`` decorators
+- **Hierarchical Organization**: Maintains logical grouping within classes and modules
+- **Pytest Integration**: Special handling for pytest fixtures with proper scope
+  ordering
+- **CLI Interface**: Simple command-line interface for easy integration
+- **Pre-commit Hook**: Ready-to-use pre-commit hook for automated code organization
+
+**************
+ Installation
+**************
+
+From PyPI:
+
+.. code-block:: bash
+
+    # using uv and add to the lint dependency group
+    uv add --group lint codesorter
+    # or using pip
+    pip install codesorter
+
+From Source:
+
+.. code-block:: bash
+
+    git clone https://github.com/praw-dev/CodeSorter.git
+    cd CodeSorter
+    uv pip install -e .
+
+Development Installation:
+
+.. code-block:: bash
+
+    git clone https://github.com/praw-dev/CodeSorter.git
+    cd CodeSorter
+    uv sync
+
+*******
+ Usage
+*******
+
+Command Line Interface
+======================
+
+The simplest way to use CodeSorter is through the command-line interface:
+
+.. code-block:: bash
+
+    # Sort a single file
+    codesorter my_file.py
+
+    # Sort all Python files in a directory
+    codesorter my_project/
+
+    # Sort with additional options
+    codesorter --help
+
+Pre-commit Hook
+===============
+
+Add CodeSorter to your pre-commit configuration to automatically sort code on every
+commit:
+
+.. code-block:: yaml
+
+    # .pre-commit-config.yaml
+    repos:
+      - repo: https://github.com/praw-dev/CodeSorter
+        rev: v0.0.3
+        hooks:
+          - id: codesorter
+
+Or use the check-only variant, which fails the hook without modifying files:
+
+.. code-block:: yaml
+
+    repos:
+      - repo: https://github.com/praw-dev/CodeSorter
+        rev: v0.0.3
+        hooks:
+          - id: codesorter-check
+
+Programmatic Usage
+==================
+
+You can also use CodeSorter programmatically:
+
+.. code-block:: python
+
+    import libcst as cst
+    from codesorter.sort_code import SortCodeCommand
+    from libcst.codemod import CodemodContext
+
+    # Parse your code
+    code = """
+    def z_function():
+        pass
+
+    def a_function():
+        pass
+    """
+
+    # Create context and command
+    context = CodemodContext()
+    command = SortCodeCommand(context)
+
+    # Transform the code
+    result = command.transform_module(cst.parse_module(code))
+    print(result.code)
+
+**************
+ How It Works
+**************
+
+CodeSorter uses LibCST (Concrete Syntax Tree) to parse and transform Python code. It
+applies sophisticated sorting rules:
+
+Function Sorting
+================
+
+- Functions are sorted alphabetically by name
+- Global functions are sorted separately from class methods
+
+Class Method Sorting
+====================
+
+- Methods are sorted with special consideration for decorators: - ``@property`` methods
+  (getters, setters, deleters) - ``@staticmethod`` methods - ``@classmethod`` methods -
+  Regular instance methods
+- Methods within classes maintain their logical grouping
+
+Pytest Fixture Sorting
+======================
+
+- Fixtures are sorted by scope (session, package, module, class, function)
+- Within each scope, fixtures are sorted alphabetically
+- ``autouse`` fixtures are handled specially
+
+Example Transformation
+======================
+
+**Before:**
+
+.. code-block:: python
+
+    class MyClass:
+        def z_method(self):
+            pass
+
+        @property
+        def a_property(self):
+            pass
+
+        @staticmethod
+        def b_static():
+            pass
+
+**After:**
+
+.. code-block:: python
+
+    class MyClass:
+        @property
+        def a_property(self):
+            pass
+
+        @staticmethod
+        def b_static():
+            pass
+
+        def z_method(self):
+            pass
+
+*************
+ Development
+*************
+
+Setting Up Development Environment
+==================================
+
+.. code-block:: bash
+
+    # Clone the repository
+    git clone https://github.com/praw-dev/CodeSorter.git
+    cd CodeSorter
+
+    # Install with development dependencies
+    uv sync
+
+    # Install pre-commit hooks
+    uv run pre-commit install
+
+Running Tests
+=============
+
+.. code-block:: bash
+
+    # Run all tests
+    uv run pytest
+
+    # Run a specific test file
+    uv run pytest tests/test_sort_code.py
+
+    # Run the full tox matrix (tests, type, pre-commit)
+    uv run tox
+
+Code Quality
+============
+
+The project uses several tools to maintain code quality:
+
+- **Ruff**: Fast linting and formatting
+- **Pyright**: Type checking
+- **Pre-commit**: Automated quality checks
+
+Run all quality checks:
+
+.. code-block:: bash
+
+    uv run pre-commit run --all-files
+
+**************
+ Contributing
+**************
+
+1. Fork the repository
+2. Create a feature branch: ``git checkout -b feature-name``
+3. Make your changes and add tests
+4. Run the test suite: ``uv run pytest``
+5. Run pre-commit hooks: ``pre-commit run --all-files``
+6. Commit your changes: ``git commit -m "Add feature"``
+7. Push to your fork: ``git push origin feature-name``
+8. Create a Pull Request
+
+**********
+ Examples
+**********
+
+See the ``examples/`` directory for before and after examples of CodeSorter in action:
+
+- ``examples/before_example.py``: Unsorted code
+- ``examples/after_example.py``: Same code after sorting
+
+*********
+ License
+*********
+
+This project is licensed under the MIT License - see the `LICENSE.txt
+<https://github.com/praw-dev/CodeSorter/blob/main/LICENSE.txt>`_ file for details.
+
+***********
+ Changelog
+***********
+
+See the `change log
+<https://codesorter.readthedocs.io/en/latest/package_info/change_log.html>`_ for the
+full list of changes.

codesorter-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+codesorter/__init__.py,sha256=LEkD4Xio5nUxV_N7WhQ7DAFfHMCEtRmRrJkODCLRAF0,120
+codesorter/cli.py,sha256=AHKOQSZBIeAWlUrUmlXWv7XB3WH6lD9Jt5WlXWzUsvQ,6845
+codesorter/const.py,sha256=6jjdeCSSO_qNISocBBTNGQJDrHy68UW5PVzk2lUak3I,390
+codesorter/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+codesorter/sort_code.py,sha256=-HaHK8V4VvCwpC8_jRb8DJddw_MsWI4i8CyfEgYo6v8,13440
+codesorter-0.1.0.dist-info/METADATA,sha256=xYYbadEngwcNCRZm0z-mXxgH1-5rkbmcw5bB-399C2w,8830
+codesorter-0.1.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+codesorter-0.1.0.dist-info/entry_points.txt,sha256=K470wbtPLAVgT0JmGTuYFKdHK7zWk_rKfrY4y0LpOyQ,47
+codesorter-0.1.0.dist-info/licenses/LICENSE.txt,sha256=_eHf9j8MG7lK9BIHqJYFtSEz85ITUVhydD8AYjHXYu4,1297
+codesorter-0.1.0.dist-info/RECORD,,

codesorter-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.30.1
+Root-Is-Purelib: true
+Tag: py3-none-any

codesorter-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+codesorter = codesorter:main

codesorter-0.1.0.dist-info/licenses/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2022, Joel Payne
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.