codesorter 0.2.5__tar.gz → 0.2.7__tar.gz

{codesorter-0.2.5 → codesorter-0.2.7}/CHANGES.rst

@@ -4,6 +4,38 @@
 
 codesorter follows `semantic versioning <https://semver.org/>`_.
 
+********************
+ 0.2.7 (2026/06/15)
+********************
+
+**Fixed**
+
+- Do not treat a class's own attribute as a dependency on a same-named outer definition.
+  An enum member or class variable named like the module constant that aliases it (for
+  example ``CACHE_MISS = _Sentinel.CACHE_MISS`` beside ``class _Sentinel(Enum):
+  CACHE_MISS = auto()``) previously forged a false ``class`` -> ``constant`` edge that
+  closed a cycle with the real ``constant`` -> ``class`` edge, hoisting the constant
+  above the class it references and raising ``NameError`` at import. A name bound in a
+  class's own body is now recognized as belonging to that class's namespace and imposes
+  no ordering on outer definitions.
+
+********************
+ 0.2.6 (2026/06/14)
+********************
+
+**Added**
+
+- Documentation page describing how barriers limit sorting to segments between
+  side-effecting statements, and how to relocate a statement that should not be a
+  barrier.
+
+**Changed**
+
+- Refresh the documentation: the installation instructions use uv-native commands, the
+  class-method ordering reference and example now match the implementation, and the
+  barrier relocation example is split into separate, color-tinted before and after
+  blocks.
+
 ********************
  0.2.5 (2026/06/14)
 ********************

{codesorter-0.2.5 → codesorter-0.2.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codesorter
-Version: 0.2.5
+Version: 0.2.7
 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/
@@ -60,6 +60,15 @@ Description-Content-Type: text/x-rst
 
 CodeSorter is a LibCST codemod that automatically sorts and organizes Python code.
 
+.. warning::
+
+    Only apply CodeSorter to a code base you own or maintain. Reordering an entire file
+    is a sweeping, opinionated change that conflicts with in-flight work and erases the
+    history of carefully chosen ordering. Opening a pull request that runs CodeSorter
+    across **someone else's** project is strongly discouraged — it is noisy,
+    unsolicited, and burdensome to review. Adopt it as a pre-commit hook in your own
+    repositories instead, where every contributor benefits from the consistent ordering.
+
 **********
  Features
 **********
@@ -85,10 +94,10 @@ From PyPI:
 
 .. code-block:: bash
 
-    # using uv and add to the lint dependency group
+    # install the codesorter CLI as a standalone tool
+    uv tool install codesorter
+    # or add it to a project's lint dependency group
     uv add --group lint codesorter
-    # or using pip
-    pip install codesorter
 
 From Source:
 
@@ -96,7 +105,7 @@ From Source:
 
     git clone https://github.com/praw-dev/CodeSorter.git
     cd CodeSorter
-    uv pip install -e .
+    uv tool install .
 
 Development Installation:
 
@@ -137,7 +146,7 @@ commit:
     # .pre-commit-config.yaml
     repos:
       - repo: https://github.com/praw-dev/CodeSorter
-        rev: v0.0.3
+        rev: v0.2.5
         hooks:
           - id: codesorter
 
@@ -147,7 +156,7 @@ Or use the check-only variant, which fails the hook without modifying files:
 
     repos:
       - repo: https://github.com/praw-dev/CodeSorter
-        rev: v0.0.3
+        rev: v0.2.5
         hooks:
           - id: codesorter-check
 
@@ -195,10 +204,18 @@ Function Sorting
 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
+- Methods are grouped by kind, in this order:
+
+  - ``@abstractmethod`` methods
+  - pytest fixtures (``autouse`` fixtures first)
+  - ``@staticmethod`` methods
+  - ``@classmethod`` methods
+  - cached properties and ``@property`` methods (getter, then setter, then deleter)
+  - ``@contextmanager`` methods
+  - regular instance methods
+
+- Within each group, methods are sorted alphabetically, with leading-underscore
+  (``_private`` and ``__dunder__``) names ahead of public ones
 
 Pytest Fixture Sorting
 ======================
@@ -231,14 +248,14 @@ Example Transformation
 .. code-block:: python
 
     class MyClass:
-        @property
-        def a_property(self):
-            pass
-
         @staticmethod
         def b_static():
             pass
 
+        @property
+        def a_property(self):
+            pass
+
         def z_method(self):
             pass
 

{codesorter-0.2.5 → codesorter-0.2.7}/README.rst

@@ -4,6 +4,15 @@
 
 CodeSorter is a LibCST codemod that automatically sorts and organizes Python code.
 
+.. warning::
+
+    Only apply CodeSorter to a code base you own or maintain. Reordering an entire file
+    is a sweeping, opinionated change that conflicts with in-flight work and erases the
+    history of carefully chosen ordering. Opening a pull request that runs CodeSorter
+    across **someone else's** project is strongly discouraged — it is noisy,
+    unsolicited, and burdensome to review. Adopt it as a pre-commit hook in your own
+    repositories instead, where every contributor benefits from the consistent ordering.
+
 **********
  Features
 **********
@@ -29,10 +38,10 @@ From PyPI:
 
 .. code-block:: bash
 
-    # using uv and add to the lint dependency group
+    # install the codesorter CLI as a standalone tool
+    uv tool install codesorter
+    # or add it to a project's lint dependency group
     uv add --group lint codesorter
-    # or using pip
-    pip install codesorter
 
 From Source:
 
@@ -40,7 +49,7 @@ From Source:
 
     git clone https://github.com/praw-dev/CodeSorter.git
     cd CodeSorter
-    uv pip install -e .
+    uv tool install .
 
 Development Installation:
 
@@ -81,7 +90,7 @@ commit:
     # .pre-commit-config.yaml
     repos:
       - repo: https://github.com/praw-dev/CodeSorter
-        rev: v0.0.3
+        rev: v0.2.5
         hooks:
           - id: codesorter
 
@@ -91,7 +100,7 @@ Or use the check-only variant, which fails the hook without modifying files:
 
     repos:
       - repo: https://github.com/praw-dev/CodeSorter
-        rev: v0.0.3
+        rev: v0.2.5
         hooks:
           - id: codesorter-check
 
@@ -139,10 +148,18 @@ Function Sorting
 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
+- Methods are grouped by kind, in this order:
+
+  - ``@abstractmethod`` methods
+  - pytest fixtures (``autouse`` fixtures first)
+  - ``@staticmethod`` methods
+  - ``@classmethod`` methods
+  - cached properties and ``@property`` methods (getter, then setter, then deleter)
+  - ``@contextmanager`` methods
+  - regular instance methods
+
+- Within each group, methods are sorted alphabetically, with leading-underscore
+  (``_private`` and ``__dunder__``) names ahead of public ones
 
 Pytest Fixture Sorting
 ======================
@@ -175,14 +192,14 @@ Example Transformation
 .. code-block:: python
 
     class MyClass:
-        @property
-        def a_property(self):
-            pass
-
         @staticmethod
         def b_static():
             pass
 
+        @property
+        def a_property(self):
+            pass
+
         def z_method(self):
             pass
 

{codesorter-0.2.5 → codesorter-0.2.7}/codesorter/const.py

@@ -39,4 +39,4 @@ PLAIN_DECORATOR_PARTS = 1
 
 PROPERTY_DECORATOR_PARTS = 2
 
-__version__ = "0.2.5"
+__version__ = "0.2.7"

{codesorter-0.2.5 → codesorter-0.2.7}/codesorter/sort_code.py

@@ -336,7 +336,24 @@ class SortCodeCommand(VisitorBasedCodemodCommand, m.MatcherDecoratableTransforme
                     # an annotation forging a false cycle with a real value-level edge.
                     if id(found["name"]) in self._lazy_annotation_names:
                         continue
-                    found_name = cst.ensure_type(found["name"], cst.Name).value
+                    name_node = cst.ensure_type(found["name"], cst.Name)
+                    found_name = name_node.value
+                    # A name bound at this class's own body level (an enum member or
+                    # class variable) belongs to the class's namespace, so it must not
+                    # forge a dependency on a same-named outer definition. Otherwise an
+                    # enum member named like the module constant that aliases it (for
+                    # example ``CACHE_MISS = _Sentinel.CACHE_MISS``) creates a false cycle
+                    # that hoists the constant above the class it depends on. The scope
+                    # must be ``node``'s own class scope; a name bound in the *enclosing*
+                    # class (a sibling method an alias assignment references) is a real
+                    # dependency and is kept.
+                    name_scope = self.get_metadata(md.ScopeProvider, name_node, None)
+                    if (
+                        isinstance(name_scope, md.ClassScope)
+                        and name_scope.node == node
+                        and name_scope.assignments[found_name]
+                    ):
+                        continue
                     is_import = isinstance(
                         next(iter(meta.assignments[found_name])),
                         md.ImportAssignment,

codesorter-0.2.7/docs/_static/custom.css

@@ -0,0 +1,26 @@
+/* Tint the before/after code blocks on the barriers page.
+   Translucent fills layer over the page background, so they read correctly in
+   both the light and dark Furo themes. */
+.codesorter-before,
+.codesorter-after {
+    border-left: 4px solid;
+    border-radius: 0.2rem;
+    margin-bottom: 1rem;
+    padding-left: 0.4rem;
+}
+
+.codesorter-before {
+    background-color: rgba(229, 83, 75, 0.08);
+    border-left-color: #e5534b;
+}
+
+.codesorter-after {
+    background-color: rgba(63, 185, 80, 0.08);
+    border-left-color: #3fb950;
+}
+
+/* Let the container tint show through instead of Furo's code background. */
+.codesorter-before div.highlight,
+.codesorter-after div.highlight {
+    background: transparent;
+}

{codesorter-0.2.5 → codesorter-0.2.7}/docs/code_overview/sort_code.rst

@@ -2,9 +2,10 @@
  Sort Code
 ###########
 
-The :class:`.SortCodeCommand` is the libcst codemod that performs the reordering. It is
-applied by the CLI, but can also be used directly as a libcst codemod (for example via
-``python -m libcst.tool codemod codesorter.sort_code.SortCodeCommand``).
+The :class:`.SortCodeCommand` is the libcst codemod that performs the reordering. The
+``codesorter`` CLI applies it to the files you pass it; you can also use it directly as
+a libcst codemod in your own tooling by constructing it with a ``CodemodContext`` and
+calling ``transform_module`` (see the programmatic example in the README).
 
 .. autoclass:: codesorter.sort_code.SortCodeCommand
 

{codesorter-0.2.5 → codesorter-0.2.7}/docs/conf.py

@@ -16,6 +16,8 @@ extensions = [
     "sphinx.ext.intersphinx",
     "sphinx_autodoc_typehints",
 ]
+html_css_files = ["custom.css"]
+html_static_path = ["_static"]
 html_theme = "furo"
 intersphinx_mapping = {
     "python": ("https://docs.python.org/3", None),

{codesorter-0.2.5 → codesorter-0.2.7}/docs/index.rst

@@ -1,5 +1,11 @@
 .. include:: ../README.rst
 
+.. toctree::
+    :hidden:
+    :caption: Usage
+
+    usage/barriers
+
 .. toctree::
     :hidden:
     :caption: Code Overview

codesorter-0.2.7/docs/usage/barriers.rst

@@ -0,0 +1,87 @@
+######################
+ Sorting and Barriers
+######################
+
+CodeSorter reorders the classes, functions, and assignments within a module or class
+body, but only within a *segment* of consecutive definitions. Any statement that is not
+a sortable definition acts as a **barrier**, and no definition is ever moved across one.
+
+Barriers include bare expression statements (a function call on its own line such as
+``sys.path.insert(0, str(ROOT))``), ``if`` / ``for`` / ``while`` / ``with`` blocks,
+``import`` statements, and similar. A barrier splits the surrounding definitions into
+independent segments, each sorted on its own.
+
+********************
+ Why barriers exist
+********************
+
+A statement sitting between definitions may depend on one of them, or be depended upon,
+in ways that reordering would break. There are two cases, and only the first is visible
+to a static tool:
+
+1. The statement *references* a definition that would otherwise move after it:
+
+   .. code-block:: python
+
+       ROOT = Path(__file__).resolve().parent
+       sys.path.insert(0, str(ROOT))  # uses ROOT
+
+   If ``ROOT`` were sorted after the ``sys.path.insert`` call, the module would raise
+   ``NameError`` on import.
+
+2. A later definition depends on the statement's *side effect*, which no name reference
+   reveals:
+
+   .. code-block:: python
+
+       configure_settings()
+       DEFAULT_TIMEOUT = settings.get("timeout")  # reads what configure_settings() set up
+
+   ``DEFAULT_TIMEOUT`` does not mention ``configure_settings`` by name, yet it must run
+   after it. Moving the constant ahead of the call would silently read an unconfigured
+   value — a wrong result rather than a crash.
+
+Because side effects are opaque, CodeSorter cannot prove that crossing an arbitrary
+statement is safe, so it treats every non-definition statement as a barrier.
+
+**********************
+ Relocating a barrier
+**********************
+
+The cost of this rule is small: a barrier that genuinely sits in the middle of a block
+of definitions keeps the definitions on either side from sorting together. If a
+statement legitimately should *not* separate your definitions — you know it has no
+ordering relationship with them — move it yourself so it no longer sits between them.
+For example, hoist a one-off call to the top of the module (just below the imports) or
+to the bottom.
+
+**Before** — the call sits between the classes, splitting them into two segments, so
+``Alpha`` and ``Beta`` cannot sort together:
+
+.. code-block:: python
+    :class: codesorter-before
+
+    class Beta: ...
+
+
+    warnings.filterwarnings("ignore")
+
+
+    class Alpha: ...
+
+**After** — relocate the call above both classes; ``Alpha`` and ``Beta`` now form a
+single segment and sort into order:
+
+.. code-block:: python
+    :class: codesorter-after
+
+    warnings.filterwarnings("ignore")
+
+
+    class Alpha: ...
+
+
+    class Beta: ...
+
+CodeSorter will not perform this move for you, precisely because it cannot prove the
+move preserves behavior — only you know whether the statement is safe to relocate.

{codesorter-0.2.5 → codesorter-0.2.7}/tests/test_files/augmented_assignment_input.py

@@ -1,12 +1,13 @@
 """Augmented assignments stay anchored to the constant they augment."""
 
-from mod import extra, more
+import enum
+import json
 
 ZEBRA = 1
 __version__ = "1.0"
 __all__ = ["Widget"]
-__all__ += extra.__all__
-__all__ += more.__all__
+__all__ += json.__all__
+__all__ += enum.__all__
 APPLE = 2
 
 

{codesorter-0.2.5 → codesorter-0.2.7}/tests/test_files/augmented_assignment_output.py

@@ -1,12 +1,13 @@
 """Augmented assignments stay anchored to the constant they augment."""
 
-from mod import extra, more
+import enum
+import json
 
 APPLE = 2
 ZEBRA = 1
 __all__ = ["Widget"]
-__all__ += extra.__all__
-__all__ += more.__all__
+__all__ += json.__all__
+__all__ += enum.__all__
 __version__ = "1.0"
 
 

codesorter-0.2.7/tests/test_files/barrier_input.py

@@ -0,0 +1,8 @@
+"""Definitions never cross a side-effecting statement that may depend on them."""
+
+ZEBRA = 1
+MIDDLE = 5
+repr(MIDDLE)  # a barrier: a bare statement splits the surrounding definitions
+
+BANANA = 3
+APPLE = 2

codesorter-0.2.7/tests/test_files/barrier_output.py

@@ -0,0 +1,8 @@
+"""Definitions never cross a side-effecting statement that may depend on them."""
+
+MIDDLE = 5
+ZEBRA = 1
+repr(MIDDLE)  # a barrier: a bare statement splits the surrounding definitions
+
+APPLE = 2
+BANANA = 3

{codesorter-0.2.5 → codesorter-0.2.7}/tests/test_files/comprehension_dependency_input.py

@@ -1,13 +1,14 @@
 """A module-level comprehension references a function eagerly, so it depends on it."""
 
-placeholders = {name: build(name) for name in ["a", "b"]}
+
+def lazy():
+    """A comprehension here is deferred, so it imposes no ordering."""
+    return [build(name) for name in ["c", "d"]]
 
 
 def build(name):
-    """Used eagerly by the module-level comprehension above."""
+    """Used eagerly by the module-level comprehension below."""
     return f"value-{name}"
 
 
-def lazy():
-    """A comprehension here is deferred, so it imposes no ordering."""
-    return [build(name) for name in ["c", "d"]]
+placeholders = {name: build(name) for name in ["a", "b"]}

{codesorter-0.2.5 → codesorter-0.2.7}/tests/test_files/comprehension_dependency_output.py

@@ -1,7 +1,8 @@
 """A module-level comprehension references a function eagerly, so it depends on it."""
 
+
 def build(name):
-    """Used eagerly by the module-level comprehension above."""
+    """Used eagerly by the module-level comprehension below."""
     return f"value-{name}"
 
 

{codesorter-0.2.5 → codesorter-0.2.7}/tests/test_files/comprehensive_input.py

@@ -1,3 +1,5 @@
+"""A comprehensive mix of constants, decorators, inheritance, and pytest fixtures."""
+
 import os
 from abc import ABC, abstractmethod
 from functools import wraps
@@ -10,7 +12,34 @@ API_KEY = "test-key-123"
 DEBUG_MODE = os.getenv("DEBUG", "false").lower() == "true"
 
 
-# Functions with decorators
+# Custom decorators (defined before the functions that use them)
+def cache_result(func):
+    """Cache the result of a function."""
+    cache = {}
+
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        key = str(args) + str(kwargs)
+        if key not in cache:
+            cache[key] = func(*args, **kwargs)
+        return cache[key]
+
+    return wrapper
+
+
+def validate_input(func):
+    """Validate input parameters."""
+
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        for arg in args:
+            if arg is None:
+                raise ValueError("Input cannot be None")
+        return func(*args, **kwargs)
+
+    return wrapper
+
+
 @cache_result
 def expensive_calculation(n):
     """Perform an expensive calculation."""
@@ -23,24 +52,21 @@ def process_data(data):
     return [item.upper() for item in data]
 
 
-class Dog(Mammal):
-    """Dog class."""
+# Base classes with inheritance (each base defined before its subclass)
+class Animal(ABC):
+    """Base class for all animals."""
 
-    def __init__(self, name, age, fur_color, breed):
-        super().__init__(name, age, fur_color)
-        self.breed = breed
+    def __init__(self, name, age):
+        self.name = name
+        self.age = age
 
+    @abstractmethod
     def make_sound(self):
-        """Make a dog sound."""
-        return "Woof!"
-
-    def get_breed_info(self):
-        """Get breed information."""
-        return f"Breed: {self.breed}"
+        """Make a sound."""
 
-    def fetch(self):
-        """Fetch behavior."""
-        return f"{self.name} is fetching"
+    def get_info(self):
+        """Get animal information."""
+        return f"{self.name} is {self.age} years old"
 
 
 class Mammal(Animal):
@@ -59,29 +85,31 @@ class Mammal(Animal):
         return f"Fur color: {self.fur_color}"
 
 
-# Base classes with inheritance
-class Animal(ABC):
-    """Base class for all animals."""
+class Dog(Mammal):
+    """Dog class."""
 
-    def __init__(self, name, age):
-        self.name = name
-        self.age = age
+    def __init__(self, name, age, fur_color, breed):
+        super().__init__(name, age, fur_color)
+        self.breed = breed
 
-    @abstractmethod
     def make_sound(self):
-        """Make a sound."""
+        """Make a dog sound."""
+        return "Woof!"
 
-    def get_info(self):
-        """Get animal information."""
-        return f"{self.name} is {self.age} years old"
+    def get_breed_info(self):
+        """Get breed information."""
+        return f"Breed: {self.breed}"
+
+    def fetch(self):
+        """Fetch behavior."""
+        return f"{self.name} is fetching"
 
 
-# Classes with global dependencies
 class DatabaseManager:
     """Manages database connections using global config."""
 
     def __init__(self):
-        self.host = "localhost"  # Would normally use DATABASE_URL
+        self.host = "localhost"
         self.port = 5432
         self.database = "test_db"
 
@@ -109,40 +137,11 @@ class APIClient:
         return DEBUG_MODE
 
 
-def validate_input(func):
-    """Validate input parameters."""
-
-    @wraps(func)
-    def wrapper(*args, **kwargs):
-        for arg in args:
-            if arg is None:
-                raise ValueError("Input cannot be None")
-        return func(*args, **kwargs)
-
-    return wrapper
-
-
 def regular_function():
     """A regular function without decorators."""
     return "regular"
 
 
-# Custom decorators
-def cache_result(func):
-    """Cache the result of a function."""
-    cache = {}
-
-    @wraps(func)
-    def wrapper(*args, **kwargs):
-        key = str(args) + str(kwargs)
-        if key not in cache:
-            cache[key] = func(*args, **kwargs)
-        return cache[key]
-
-    return wrapper
-
-
-# Test functions
 def test_something(database_connection, sample_data):
     """Test function using fixtures."""
     assert database_connection["connected"]
@@ -171,7 +170,6 @@ def sample_data():
     return ["item1", "item2", "item3"]
 
 
-# Pytest fixtures
 @pytest.fixture(scope="session")
 def database_connection():
     """Provide a database connection for testing."""

{codesorter-0.2.5 → codesorter-0.2.7}/tests/test_files/comprehensive_output.py

@@ -1,10 +1,12 @@
+"""A comprehensive mix of constants, decorators, inheritance, and pytest fixtures."""
+
 import os
 from abc import ABC, abstractmethod
 from functools import wraps
 
 import pytest
-API_KEY = "test-key-123"
 
+API_KEY = "test-key-123"
 # Global variables
 DATABASE_URL = "sqlite:///test.db"
 DEBUG_MODE = os.getenv("DEBUG", "false").lower() == "true"
@@ -25,7 +27,7 @@ class APIClient:
         return f"GET {self.base_url}{endpoint}"
 
 
-# Base classes with inheritance
+# Base classes with inheritance (each base defined before its subclass)
 class Animal(ABC):
     """Base class for all animals."""
 
@@ -42,12 +44,11 @@ class Animal(ABC):
         return f"{self.name} is {self.age} years old"
 
 
-# Classes with global dependencies
 class DatabaseManager:
     """Manages database connections using global config."""
 
     def __init__(self):
-        self.host = "localhost"  # Would normally use DATABASE_URL
+        self.host = "localhost"
         self.port = 5432
         self.database = "test_db"
 
@@ -105,7 +106,6 @@ def setup_test_environment():
     API_KEY = "test-key-123"
 
 
-# Pytest fixtures
 @pytest.fixture(scope="session")
 def database_connection():
     """Provide a database connection for testing."""
@@ -118,7 +118,7 @@ def sample_data():
     return ["item1", "item2", "item3"]
 
 
-# Custom decorators
+# Custom decorators (defined before the functions that use them)
 def cache_result(func):
     """Cache the result of a function."""
     cache = {}
@@ -133,7 +133,6 @@ def cache_result(func):
     return wrapper
 
 
-# Functions with decorators
 @cache_result
 def expensive_calculation(n):
     """Perform an expensive calculation."""
@@ -161,7 +160,6 @@ def test_global_dependencies():
     assert api_client.is_debug_mode() == DEBUG_MODE
 
 
-# Test functions
 def test_something(database_connection, sample_data):
     """Test function using fixtures."""
     assert database_connection["connected"]

codesorter-0.2.7/tests/test_files/enum_member_alias_input.py

@@ -0,0 +1,12 @@
+from enum import Enum, auto
+
+
+def helper():
+    return CACHE_MISS
+
+
+class _Sentinel(Enum):
+    CACHE_MISS = auto()
+
+
+CACHE_MISS = _Sentinel.CACHE_MISS

codesorter-0.2.7/tests/test_files/enum_member_alias_output.py

@@ -0,0 +1,12 @@
+from enum import Enum, auto
+
+
+class _Sentinel(Enum):
+    CACHE_MISS = auto()
+
+
+CACHE_MISS = _Sentinel.CACHE_MISS
+
+
+def helper():
+    return CACHE_MISS

{codesorter-0.2.5 → codesorter-0.2.7}/tests/test_files/name_rebinding_input.py

@@ -1,6 +1,11 @@
 """An assignment that rebinds a method name stays after the method it wraps."""
 
 
+def cachedproperty(method, *, doc=None):
+    """Minimal stand-in so the rebinding has something to call."""
+    return property(method)
+
+
 class Klass:
     def ten(self):
         return 10

{codesorter-0.2.5 → codesorter-0.2.7}/tests/test_files/name_rebinding_output.py

@@ -1,6 +1,11 @@
 """An assignment that rebinds a method name stays after the method it wraps."""
 
 
+def cachedproperty(method, *, doc=None):
+    """Minimal stand-in so the rebinding has something to call."""
+    return property(method)
+
+
 class Klass:
     def alpha(self):
         """A method that sorts first alphabetically."""

{codesorter-0.2.5 → codesorter-0.2.7}/tests/test_sort_code.py

@@ -1,5 +1,9 @@
 """Tests for the SortCodeCommand codemod."""
 
+import io
+from contextlib import redirect_stderr, redirect_stdout
+from pathlib import Path
+
 import libcst as cst
 import pytest
 from libcst.codemod import CodemodContext
@@ -183,6 +187,52 @@ class MyClass:
         result = command.transform_module(cst.parse_module(code))
         assert result.code.strip() == ""
 
+    def test_enum_member_alias(self, test_files):
+        """Test that a class attribute sharing a name with an outer constant is not a dep.
+
+        An enum member (or class variable) named like the module constant that aliases
+        it (``CACHE_MISS = _Sentinel.CACHE_MISS``) is bound in the class's own
+        namespace, so it must not forge a dependency from the class back onto the
+        constant. Without that guard the false ``_Sentinel`` -> ``CACHE_MISS`` edge
+        closes a cycle with the real ``CACHE_MISS`` -> ``_Sentinel`` edge, and
+        cycle-breaking hoists the constant above the class it references (raising
+        NameError at import).
+
+        """
+        input_code, expected_code = test_files
+        context = CodemodContext()
+        command = SortCodeCommand(context)
+        result = command.transform_module(cst.parse_module(input_code))
+
+        assert expected_code == result.code
+
+    def test_fixture_files_execute(self):
+        """Every input/output fixture must import cleanly with no side effects.
+
+        Executing each file in a fresh namespace is a stronger guard than parsing: it
+        catches a fixture that parses but does not run (an invalid input, or a codemod
+        output that raises ``NameError`` because a definition was hoisted above one it
+        depends on). Each file is also required to be self-contained and side-effect
+        free, so anything written to stdout/stderr fails the test.
+
+        """
+        test_files_dir = Path(__file__).parent / "test_files"
+        fixtures = sorted(test_files_dir.glob("*.py"))
+        assert fixtures, "no fixture files found"
+        failures = []
+        for path in fixtures:
+            captured = io.StringIO()
+            try:
+                code = compile(path.read_text(encoding="utf-8"), str(path), "exec")
+                with redirect_stdout(captured), redirect_stderr(captured):
+                    exec(code, {"__name__": "__fixture__"})  # noqa: S102
+            except Exception as error:  # noqa: BLE001
+                failures.append(f"{path.name}: {type(error).__name__}: {error}")
+                continue
+            if captured.getvalue():
+                failures.append(f"{path.name}: wrote to stdout/stderr {captured.getvalue()!r}")
+        assert not failures, "fixtures that do not execute cleanly:\n" + "\n".join(failures)
+
     def test_keyword_arguments(self, test_files):
         """Test that keyword arguments, keyword-only params, and dict keys are sorted."""
         input_code, expected_code = test_files

codesorter-0.2.5/tests/test_files/barrier_input.py

@@ -1,11 +0,0 @@
-"""Definitions never cross a side-effecting statement that may depend on them."""
-
-import sys
-from pathlib import Path
-
-ZEBRA = 1
-REPO_ROOT = Path(__file__).resolve().parent
-sys.path.insert(0, str(REPO_ROOT))
-
-BANANA = 3
-APPLE = 2

codesorter-0.2.5/tests/test_files/barrier_output.py

@@ -1,11 +0,0 @@
-"""Definitions never cross a side-effecting statement that may depend on them."""
-
-import sys
-from pathlib import Path
-
-REPO_ROOT = Path(__file__).resolve().parent
-ZEBRA = 1
-sys.path.insert(0, str(REPO_ROOT))
-
-APPLE = 2
-BANANA = 3

{codesorter-0.2.5 → codesorter-0.2.7}/tests/test_files/lazy_annotation_cycle_input.py

@@ -3,12 +3,6 @@
 from __future__ import annotations
 
 
-class Apple(_Base):
-    """References the Instr alias only in a lazy annotation."""
-
-    nxt: list[Instr]
-
-
 class _Base:
     """A shared base class."""
 
@@ -17,10 +11,16 @@ class Zebra(_Base):
     """Another member of the Instr union."""
 
 
-Instr = Apple | Zebra
+class Apple(_Base):
+    """References the Instr alias only in a lazy annotation."""
+
+    nxt: list[Instr]
 
 
 class User:
     """Uses the Instr alias in a lazy annotation."""
 
     items: list[Instr]
+
+
+Instr = Apple | Zebra