codesorter 0.1.0__tar.gz → 0.2.1__tar.gz

{codesorter-0.1.0 → codesorter-0.2.1}/.pre-commit-config.yaml

@@ -1,13 +1,15 @@
 repos:
-  - repo: local
-    hooks:
-      - always_run: true
-        entry: codesorter --exclude examples --exclude test_files
+  - hooks:
+      # Self-hosted: run codesorter from the local checkout rather than a pinned
+      # release so the repository is always sorted by its own current code.
+      - entry: codesorter
+        exclude: ^(examples|tests/test_files)/
         id: codesorter
         language: system
         name: codesorter
-        pass_filenames: false
-        types: [ python ]
+        require_serial: true
+        types: [python]
+    repo: local
 
   - hooks:
       - id: docstrfmt

codesorter-0.2.1/CHANGES.rst

@@ -0,0 +1,83 @@
+############
+ Change Log
+############
+
+codesorter follows `semantic versioning <https://semver.org/>`_.
+
+********************
+ 0.2.1 (2026/06/14)
+********************
+
+**Fixed**
+
+- Treat a name used inside a module- or class-level comprehension as a real dependency.
+  Such a comprehension runs eagerly when the definition executes, so an assignment like
+  ``values = {key: build(key) for key in keys}`` now sorts after the ``build`` function
+  it calls instead of ahead of it (which raised ``NameError``). A comprehension inside a
+  function body stays deferred and still imposes no ordering.
+
+********************
+ 0.2.0 (2026/06/14)
+********************
+
+**Added**
+
+- Sort module- and class-level assignments. Within every scope the order is now
+  assignments, then classes, then functions/methods, so methods always follow nested
+  classes and assignments are grouped at the top. Assignments are split into uppercase
+  ``CONSTANTS`` first and then other variables; each group sorts with a leading
+  underscore first (so ``__dunder__`` and ``_private`` precede public names), and
+  dependencies are respected (``B = A + 1`` stays after ``A``). As a result,
+  module-level functions now sort after module-level classes. The attribute order of
+  enums, dataclasses, and ``NamedTuple``/``TypedDict`` classes is preserved; the base or
+  decorator is resolved through ``QualifiedNameProvider`` so aliased imports (``from
+  enum import IntEnum as IE``) are recognized.
+- Keep blank-line spacing with its position rather than the moved definition, so
+  reordering no longer drags a blank line onto a different statement (for example the
+  blank line after a class docstring stays at the top of the block). Comment lines that
+  sit directly above a definition still travel with it.
+- Keep an augmented assignment anchored to the constant it augments, so ``__all__ +=
+  extra`` stays directly after ``__all__ = [...]`` instead of being left behind as a
+  fixed barrier when another assignment sorts between them.
+- Sort keyword arguments in calls, keyword-only parameters in function definitions, and
+  string keys in dict literals alphabetically. In a call, keyword arguments are sorted
+  and ``**`` unpackings moved to the end (positional arguments and ``*`` unpackings stay
+  put), which is safe because a call raises ``TypeError`` on any duplicate keyword
+  regardless of order. In a dict literal, ``**`` spreads and non-string keys act as
+  barriers so last-wins merge semantics are preserved.
+
+**Changed**
+
+- Sort ``_``-prefixed (private and dunder) names ahead of public names at every level
+  rather than after capitalized names. A plain string sort placed ``_`` after
+  ``A``-``Z`` because of its higher code point; names are now ordered on a
+  leading-underscore flag first so private definitions, methods, keyword arguments, and
+  dict keys group together ahead of the public ones.
+
+**Fixed**
+
+- Ignore a name used only in a lazy annotation (under ``from __future__ import
+  annotations``) when ordering definitions, since the annotation is never evaluated at
+  runtime and imposes no real dependency. A forward reference in an annotation (for
+  example ``nxt: list[Instr]`` where ``Instr`` is a type-alias union of classes defined
+  later) previously forged a false dependency cycle that could hoist the runtime alias
+  above the classes it unions and raise ``NameError``.
+- Order definitions with a proper priority topological sort so a class or function is
+  always placed after every sibling it depends on. The previous dependency heuristic
+  compared per-node dependency vectors and could emit a dependent before its dependency
+  (for example, ``Subreddit``'s ``SubredditFlair`` was sorted ahead of the
+  flair-template classes it instantiates).
+
+********************
+ 0.1.0 (2026/06/14)
+********************
+
+**Added**
+
+- Initial release of CodeSorter.
+- CLI interface with directory walking, sensible default excludes, ``.gitignore``
+  honoring, and ``-e/--exclude`` / ``--no-default-excludes`` / ``--no-gitignore`` flags.
+- Pre-commit hooks (``codesorter`` and ``codesorter-check``) for downstream consumers.
+- Comprehensive test suite covering function, method, property, fixture, decorator, and
+  inheritance sort behaviors.
+- Example before/after files in ``examples/``.

{codesorter-0.1.0 → codesorter-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codesorter
-Version: 0.1.0
+Version: 0.2.1
 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/
@@ -67,6 +67,10 @@ CodeSorter is a LibCST codemod that automatically sorts and organizes Python cod
 - **Decorator Awareness**: Properly handles ``@property``, ``@staticmethod``,
   ``@classmethod``, and ``@pytest.fixture`` decorators
 - **Hierarchical Organization**: Maintains logical grouping within classes and modules
+- **Constant Grouping**: Orders each scope as constants, then classes, then functions,
+  sorting constants by dependency while preserving enum and dataclass field order
+- **Keyword Sorting**: Alphabetizes keyword arguments in calls, keyword-only parameters,
+  and dict string keys, while preserving ``*``/``**`` unpacking semantics
 - **Pytest Integration**: Special handling for pytest fixtures with proper scope
   ordering
 - **CLI Interface**: Simple command-line interface for easy integration

{codesorter-0.1.0 → codesorter-0.2.1}/README.rst

@@ -12,6 +12,10 @@ CodeSorter is a LibCST codemod that automatically sorts and organizes Python cod
 - **Decorator Awareness**: Properly handles ``@property``, ``@staticmethod``,
   ``@classmethod``, and ``@pytest.fixture`` decorators
 - **Hierarchical Organization**: Maintains logical grouping within classes and modules
+- **Constant Grouping**: Orders each scope as constants, then classes, then functions,
+  sorting constants by dependency while preserving enum and dataclass field order
+- **Keyword Sorting**: Alphabetizes keyword arguments in calls, keyword-only parameters,
+  and dict string keys, while preserving ``*``/``**`` unpacking semantics
 - **Pytest Integration**: Special handling for pytest fixtures with proper scope
   ordering
 - **CLI Interface**: Simple command-line interface for easy integration

{codesorter-0.1.0 → codesorter-0.2.1}/codesorter/cli.py

@@ -22,13 +22,13 @@ if TYPE_CHECKING:
 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,
+        prog="codesorter",
     )
     parser.add_argument(
         "-c",
@@ -39,8 +39,8 @@ def _build_parser() -> argparse.ArgumentParser:
     parser.add_argument(
         "-j",
         "--jobs",
-        type=int,
         help="Number of jobs to use when processing files.",
+        type=int,
     )
     parser.add_argument(
         "-s",
@@ -57,11 +57,11 @@ def _build_parser() -> argparse.ArgumentParser:
     parser.add_argument(
         "-e",
         "--exclude",
-        dest="extra_excludes",
         action="append",
         default=[],
-        metavar="NAME",
+        dest="extra_excludes",
         help="Directory name to skip when walking paths. May be passed multiple times.",
+        metavar="NAME",
     )
     parser.add_argument(
         "--no-default-excludes",
@@ -75,8 +75,8 @@ def _build_parser() -> argparse.ArgumentParser:
     )
     parser.add_argument(
         "paths",
-        nargs="*",
         help="Files or directories to sort. Defaults to the current directory.",
+        nargs="*",
     )
     return parser
 
@@ -130,7 +130,7 @@ def _collect_files(
                 files.append(str(path))
             continue
 
-        ignore_specs = _load_gitignore_specs(root=path, excludes=excludes) if honor_gitignore else []
+        ignore_specs = _load_gitignore_specs(excludes=excludes, root=path) if honor_gitignore else []
 
         for candidate in sorted(path.rglob("*.py")):
             relative_parts = candidate.relative_to(path).parts
@@ -148,8 +148,8 @@ def _collect_files(
 
 def _load_gitignore_specs(
     *,
-    root: Path,
     excludes: set[str],
+    root: Path,
 ) -> list[tuple[Path, pathspec.PathSpec[Pattern]]]:
     """Collect (anchor_dir, spec) for every .gitignore at or below root.
 

codesorter-0.2.1/codesorter/const.py

@@ -0,0 +1,42 @@
+"""Package constants and version metadata."""
+
+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",
+)
+# Bases and decorators that make a class body order-sensitive, so its attribute
+# assignments must not be reordered (enum member order sets the values; dataclass and
+# NamedTuple/TypedDict field order sets the generated signature).
+ORDER_SENSITIVE_BASES: frozenset[str] = frozenset({
+    "Enum",
+    "IntEnum",
+    "StrEnum",
+    "Flag",
+    "IntFlag",
+    "ReprEnum",
+    "NamedTuple",
+    "TypedDict",
+})
+ORDER_SENSITIVE_DECORATORS: frozenset[str] = frozenset({"dataclass", "define", "frozen", "mutable", "attrs"})
+PLAIN_DECORATOR_PARTS = 1
+
+PROPERTY_DECORATOR_PARTS = 2
+
+__version__ = "0.2.1"