undersort 0.1.3__tar.gz → 0.1.5__tar.gz

{undersort-0.1.3 → undersort-0.1.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: undersort
-Version: 0.1.3
+Version: 0.1.5
 Summary: A tool to sort class methods by visibility (public, protected, private)
 Project-URL: Homepage, https://github.com/kivicode/undersort
 Project-URL: Repository, https://github.com/kivicode/undersort
@@ -68,6 +68,10 @@ order = ["public", "protected", "private"]
 # Options: "class" (classmethod), "static" (staticmethod), "instance" (regular methods)
 # Default: ["instance", "class", "static"]
 method_type_order = ["instance", "class", "static"]
+
+# Exclude files/directories matching these patterns (optional)
+# Patterns support glob syntax (e.g., "tests/*", "migrations/*.py", "**/generated/*")
+# exclude = ["tests/*", "migrations/*.py"]
 ```
 
 ### Method Visibility Rules
@@ -107,6 +111,51 @@ Example order with default configuration:
 8. Private class methods
 9. Private static methods
 
+### Skipping Sorting with `# nosort`
+
+You can prevent sorting at different levels using `# nosort` comments (case-insensitive):
+
+**File-level**: Skip entire file
+
+```python
+# nosort: file
+class Example:
+    def _protected(self):
+        pass
+    def public(self):
+        pass  # File won't be sorted
+```
+
+**Class-level**: Skip specific class
+
+```python
+class Example:  # nosort
+    def _protected(self):
+        pass
+    def public(self):
+        pass  # This class won't be sorted
+
+class Other:
+    def _protected(self):
+        pass
+    def public(self):
+        pass  # This class WILL be sorted
+```
+
+**Method-level**: Keep method in its current position
+
+```python
+class Example:
+    def public_a(self):
+        pass
+
+    def _protected(self):  # nosort
+        pass  # Stays here, between public methods
+
+    def public_b(self):
+        pass  # Will move up, but _protected stays in place
+```
+
 ## Usage
 
 ### Command Line
@@ -140,9 +189,15 @@ undersort --diff example.py
 
 # Combine flags
 undersort --check --diff src/
+
+# Exclude specific files or directories
+undersort --exclude "tests/*" --exclude "migrations/*.py" src/
+
+# Multiple exclude patterns (can be combined with config file patterns)
+undersort --exclude "test_*.py" --exclude "*/legacy/*" .
 ```
 
-**Note**: By default, undersort excludes all dot-prefixed directories (e.g., `.venv`, `.git`, `.pytest_cache`) and common build directories (`venv`, `__pycache__`, `node_modules`) when scanning directories recursively.
+**Note**: By default, undersort excludes all dot-prefixed directories (e.g., `.venv`, `.git`, `.pytest_cache`) and common build directories (`venv`, `__pycache__`, `node_modules`) when scanning directories recursively. You can add custom exclusions via CLI flags or the config file.
 
 ### Pre-commit Integration
 

{undersort-0.1.3 → undersort-0.1.5}/README.md

@@ -41,6 +41,10 @@ order = ["public", "protected", "private"]
 # Options: "class" (classmethod), "static" (staticmethod), "instance" (regular methods)
 # Default: ["instance", "class", "static"]
 method_type_order = ["instance", "class", "static"]
+
+# Exclude files/directories matching these patterns (optional)
+# Patterns support glob syntax (e.g., "tests/*", "migrations/*.py", "**/generated/*")
+# exclude = ["tests/*", "migrations/*.py"]
 ```
 
 ### Method Visibility Rules
@@ -80,6 +84,51 @@ Example order with default configuration:
 8. Private class methods
 9. Private static methods
 
+### Skipping Sorting with `# nosort`
+
+You can prevent sorting at different levels using `# nosort` comments (case-insensitive):
+
+**File-level**: Skip entire file
+
+```python
+# nosort: file
+class Example:
+    def _protected(self):
+        pass
+    def public(self):
+        pass  # File won't be sorted
+```
+
+**Class-level**: Skip specific class
+
+```python
+class Example:  # nosort
+    def _protected(self):
+        pass
+    def public(self):
+        pass  # This class won't be sorted
+
+class Other:
+    def _protected(self):
+        pass
+    def public(self):
+        pass  # This class WILL be sorted
+```
+
+**Method-level**: Keep method in its current position
+
+```python
+class Example:
+    def public_a(self):
+        pass
+
+    def _protected(self):  # nosort
+        pass  # Stays here, between public methods
+
+    def public_b(self):
+        pass  # Will move up, but _protected stays in place
+```
+
 ## Usage
 
 ### Command Line
@@ -113,9 +162,15 @@ undersort --diff example.py
 
 # Combine flags
 undersort --check --diff src/
+
+# Exclude specific files or directories
+undersort --exclude "tests/*" --exclude "migrations/*.py" src/
+
+# Multiple exclude patterns (can be combined with config file patterns)
+undersort --exclude "test_*.py" --exclude "*/legacy/*" .
 ```
 
-**Note**: By default, undersort excludes all dot-prefixed directories (e.g., `.venv`, `.git`, `.pytest_cache`) and common build directories (`venv`, `__pycache__`, `node_modules`) when scanning directories recursively.
+**Note**: By default, undersort excludes all dot-prefixed directories (e.g., `.venv`, `.git`, `.pytest_cache`) and common build directories (`venv`, `__pycache__`, `node_modules`) when scanning directories recursively. You can add custom exclusions via CLI flags or the config file.
 
 ### Pre-commit Integration
 

{undersort-0.1.3 → undersort-0.1.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "undersort"
-version = "0.1.3"
+version = "0.1.5"
 description = "A tool to sort class methods by visibility (public, protected, private)"
 authors = [{ name = "KiviCode", email = "kivicode.dev@gmail.com" }]
 readme = "README.md"
@@ -50,6 +50,10 @@ order = ["public", "protected", "private"]
 # Default order if not specified: ["instance", "class", "static"]
 method_type_order = ["instance", "class", "static"]
 
+# Exclude files/directories matching these patterns (optional)
+# Patterns support glob syntax (e.g., "tests/*", "migrations/*.py", "**/generated/*")
+# exclude = ["tests/*", "migrations/*.py"]
+
 [tool.ruff]
 unsafe-fixes = true
 exclude = [".venv"]

{undersort-0.1.3 → undersort-0.1.5}/tests/test_config.py

@@ -14,7 +14,7 @@ class TestConfigLoading:
         """Test that default config is returned when no pyproject.toml exists."""
         monkeypatch.chdir(tmp_path)
         config = load_config()
-        assert config == {"order": ["public", "protected", "private"], "method_type_order": None}
+        assert config == {"order": ["public", "protected", "private"], "method_type_order": None, "exclude": None}
 
     def test_load_custom_order(self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
         """Test loading custom order from pyproject.toml."""
@@ -27,7 +27,7 @@ order = ["private", "protected", "public"]
 
         monkeypatch.chdir(tmp_path)
         config = load_config()
-        assert config == {"order": ["private", "protected", "public"], "method_type_order": None}
+        assert config == {"order": ["private", "protected", "public"], "method_type_order": None, "exclude": None}
 
     def test_invalid_order_values(self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
         """Test that invalid order values fall back to default."""
@@ -40,7 +40,7 @@ order = ["public", "invalid", "private"]
 
         monkeypatch.chdir(tmp_path)
         config = load_config()
-        assert config == {"order": ["public", "protected", "private"], "method_type_order": None}
+        assert config == {"order": ["public", "protected", "private"], "method_type_order": None, "exclude": None}
 
     def test_missing_order_key(self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
         """Test that missing order key returns default."""
@@ -53,7 +53,7 @@ some_other_key = "value"
 
         monkeypatch.chdir(tmp_path)
         config = load_config()
-        assert config == {"order": ["public", "protected", "private"], "method_type_order": None}
+        assert config == {"order": ["public", "protected", "private"], "method_type_order": None, "exclude": None}
 
     def test_missing_tool_section(self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
         """Test that missing tool.undersort section returns default."""
@@ -66,7 +66,7 @@ name = "test"
 
         monkeypatch.chdir(tmp_path)
         config = load_config()
-        assert config == {"order": ["public", "protected", "private"], "method_type_order": None}
+        assert config == {"order": ["public", "protected", "private"], "method_type_order": None, "exclude": None}
 
     def test_find_pyproject_in_parent(self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
         """Test that pyproject.toml is found in parent directories."""
@@ -84,7 +84,7 @@ order = ["private", "public", "protected"]
         monkeypatch.chdir(subdir)
 
         config = load_config()
-        assert config == {"order": ["private", "public", "protected"], "method_type_order": None}
+        assert config == {"order": ["private", "public", "protected"], "method_type_order": None, "exclude": None}
 
     def test_corrupted_toml(self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
         """Test that corrupted TOML file falls back to default."""
@@ -97,7 +97,7 @@ order = ["public"  # Invalid TOML
 
         monkeypatch.chdir(tmp_path)
         config = load_config()
-        assert config == {"order": ["public", "protected", "private"], "method_type_order": None}
+        assert config == {"order": ["public", "protected", "private"], "method_type_order": None, "exclude": None}
 
     def test_find_pyproject_toml_not_found(self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
         """Test _find_pyproject_toml returns None when not found."""
@@ -113,3 +113,39 @@ order = ["public"  # Invalid TOML
         monkeypatch.chdir(tmp_path)
         result = _find_pyproject_toml()
         assert result == pyproject_path
+
+    def test_load_exclude_patterns(self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
+        """Test loading exclude patterns from pyproject.toml."""
+        pyproject_content = """
+[tool.undersort]
+order = ["public", "protected", "private"]
+exclude = ["tests/*", "migrations/*.py"]
+"""
+        pyproject_path = tmp_path / "pyproject.toml"
+        pyproject_path.write_text(pyproject_content)
+
+        monkeypatch.chdir(tmp_path)
+        config = load_config()
+        assert config == {
+            "order": ["public", "protected", "private"],
+            "method_type_order": None,
+            "exclude": ["tests/*", "migrations/*.py"],
+        }
+
+    def test_invalid_exclude_type(self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
+        """Test that invalid exclude type falls back to None."""
+        pyproject_content = """
+[tool.undersort]
+order = ["public", "protected", "private"]
+exclude = "invalid"
+"""
+        pyproject_path = tmp_path / "pyproject.toml"
+        pyproject_path.write_text(pyproject_content)
+
+        monkeypatch.chdir(tmp_path)
+        config = load_config()
+        assert config == {
+            "order": ["public", "protected", "private"],
+            "method_type_order": None,
+            "exclude": None,
+        }

{undersort-0.1.3 → undersort-0.1.5}/tests/test_main.py

@@ -107,3 +107,75 @@ class TestCollectPythonFiles:
         assert result[0].name == "a.py"
         assert result[1].name == "b.py"
         assert result[2].name == "c.py"
+
+    def test_exclude_patterns_simple(self, tmp_path: Path) -> None:
+        """Test excluding files by simple pattern."""
+        (tmp_path / "main.py").write_text("# main")
+        (tmp_path / "test.py").write_text("# test")
+        (tmp_path / "setup.py").write_text("# setup")
+
+        result = collect_python_files(tmp_path, recursive=False, exclude_patterns=["test.py"])
+
+        assert len(result) == 2
+        assert any(f.name == "main.py" for f in result)
+        assert any(f.name == "setup.py" for f in result)
+        assert not any(f.name == "test.py" for f in result)
+
+    def test_exclude_patterns_wildcard(self, tmp_path: Path) -> None:
+        """Test excluding files by wildcard pattern."""
+        (tmp_path / "main.py").write_text("# main")
+        (tmp_path / "test_one.py").write_text("# test")
+        (tmp_path / "test_two.py").write_text("# test")
+
+        result = collect_python_files(tmp_path, recursive=False, exclude_patterns=["test_*.py"])
+
+        assert len(result) == 1
+        assert result[0].name == "main.py"
+
+    def test_exclude_patterns_directory(self, tmp_path: Path) -> None:
+        """Test excluding entire directories."""
+        (tmp_path / "main.py").write_text("# main")
+        (tmp_path / "tests").mkdir()
+        (tmp_path / "tests" / "test_one.py").write_text("# test")
+        (tmp_path / "tests" / "test_two.py").write_text("# test")
+        (tmp_path / "src").mkdir()
+        (tmp_path / "src" / "app.py").write_text("# app")
+
+        result = collect_python_files(tmp_path, recursive=True, exclude_patterns=["tests/*"])
+
+        assert len(result) == 2
+        assert any(f.name == "main.py" for f in result)
+        assert any(f.name == "app.py" for f in result)
+        assert not any("test" in f.name for f in result)
+
+    def test_exclude_patterns_multiple(self, tmp_path: Path) -> None:
+        """Test excluding with multiple patterns."""
+        (tmp_path / "main.py").write_text("# main")
+        (tmp_path / "test.py").write_text("# test")
+        (tmp_path / "migrations").mkdir()
+        (tmp_path / "migrations" / "001.py").write_text("# migration")
+        (tmp_path / "src").mkdir()
+        (tmp_path / "src" / "app.py").write_text("# app")
+
+        result = collect_python_files(tmp_path, recursive=True, exclude_patterns=["test.py", "migrations/*"])
+
+        assert len(result) == 2
+        assert any(f.name == "main.py" for f in result)
+        assert any(f.name == "app.py" for f in result)
+        assert not any(f.name == "test.py" for f in result)
+        assert not any("001.py" in str(f) for f in result)
+
+    def test_exclude_patterns_nested_directories(self, tmp_path: Path) -> None:
+        """Test excluding nested directories."""
+        (tmp_path / "main.py").write_text("# main")
+        (tmp_path / "tests").mkdir()
+        (tmp_path / "tests" / "unit").mkdir()
+        (tmp_path / "tests" / "unit" / "test_one.py").write_text("# test")
+        (tmp_path / "src").mkdir()
+        (tmp_path / "src" / "app.py").write_text("# app")
+
+        result = collect_python_files(tmp_path, recursive=True, exclude_patterns=["tests/*"])
+
+        assert len(result) == 2
+        assert any(f.name == "main.py" for f in result)
+        assert any(f.name == "app.py" for f in result)

undersort-0.1.5/tests/test_nosort.py

@@ -0,0 +1,190 @@
+"""Tests for nosort comment directives."""
+
+import tempfile
+from pathlib import Path
+
+from undersort.sorter import sort_file
+
+
+class TestNosortDirectives:
+    """Tests for # nosort comment functionality."""
+
+    def test_file_level_nosort(self) -> None:
+        """Test that file-level nosort prevents all sorting."""
+        source = """# nosort: file
+class Example:
+    def _protected(self):
+        pass
+
+    def public(self):
+        pass
+"""
+        with tempfile.NamedTemporaryFile(mode="w", suffix=".py", delete=False) as f:
+            f.write(source)
+            temp_path = Path(f.name)
+
+        try:
+            order = ["public", "protected", "private"]
+            was_modified = sort_file(temp_path, order)
+
+            assert was_modified is False
+
+            with open(temp_path) as f:
+                result = f.read()
+
+            assert result == source
+        finally:
+            temp_path.unlink()
+
+    def test_class_level_nosort(self) -> None:
+        """Test that class-level nosort prevents sorting that class."""
+        source = """class Example:  # nosort
+    def _protected(self):
+        pass
+
+    def public(self):
+        pass
+"""
+        with tempfile.NamedTemporaryFile(mode="w", suffix=".py", delete=False) as f:
+            f.write(source)
+            temp_path = Path(f.name)
+
+        try:
+            order = ["public", "protected", "private"]
+            was_modified = sort_file(temp_path, order)
+
+            assert was_modified is False
+
+            with open(temp_path) as f:
+                result = f.read()
+
+            assert result == source
+        finally:
+            temp_path.unlink()
+
+    def test_method_level_nosort(self) -> None:
+        """Test that method-level nosort keeps that method in place."""
+        source = """class Example:
+    def public_a(self):
+        pass
+
+    def _protected_x(self):  # nosort
+        pass
+
+    def public_b(self):
+        pass
+"""
+        with tempfile.NamedTemporaryFile(mode="w", suffix=".py", delete=False) as f:
+            f.write(source)
+            temp_path = Path(f.name)
+
+        try:
+            order = ["public", "protected", "private"]
+            was_modified = sort_file(temp_path, order)
+
+            assert was_modified is False
+
+            with open(temp_path) as f:
+                result = f.read()
+
+            protected_idx = result.find("def _protected_x")
+            public_a_idx = result.find("def public_a")
+            public_b_idx = result.find("def public_b")
+
+            assert public_a_idx < protected_idx < public_b_idx
+        finally:
+            temp_path.unlink()
+
+    def test_multiple_nosort_methods(self) -> None:
+        """Test multiple methods with nosort."""
+        source = """class Example:
+    def public_a(self):
+        pass
+
+    def _protected_x(self):  # nosort
+        pass
+
+    def public_b(self):  # nosort
+        pass
+
+    def _protected_y(self):
+        pass
+"""
+        with tempfile.NamedTemporaryFile(mode="w", suffix=".py", delete=False) as f:
+            f.write(source)
+            temp_path = Path(f.name)
+
+        try:
+            order = ["public", "protected", "private"]
+            was_modified = sort_file(temp_path, order)
+
+            assert was_modified is False
+
+            with open(temp_path) as f:
+                result = f.read()
+
+            assert result == source
+        finally:
+            temp_path.unlink()
+
+    def test_nosort_case_insensitive(self) -> None:
+        """Test that NOSORT and NoSort also work."""
+        source = """class Example:  # NOSORT
+    def _protected(self):
+        pass
+
+    def public(self):
+        pass
+"""
+        with tempfile.NamedTemporaryFile(mode="w", suffix=".py", delete=False) as f:
+            f.write(source)
+            temp_path = Path(f.name)
+
+        try:
+            order = ["public", "protected", "private"]
+            was_modified = sort_file(temp_path, order)
+
+            assert was_modified is False
+        finally:
+            temp_path.unlink()
+
+    def test_nosort_with_other_classes(self) -> None:
+        """Test that nosort on one class doesn't affect others."""
+        source = """class First:  # nosort
+    def _protected(self):
+        pass
+
+    def public(self):
+        pass
+
+class Second:
+    def _protected(self):
+        pass
+
+    def public(self):
+        pass
+"""
+        with tempfile.NamedTemporaryFile(mode="w", suffix=".py", delete=False) as f:
+            f.write(source)
+            temp_path = Path(f.name)
+
+        try:
+            order = ["public", "protected", "private"]
+            was_modified = sort_file(temp_path, order)
+
+            assert was_modified is True
+
+            with open(temp_path) as f:
+                result = f.read()
+
+            first_protected_idx = result.find("class First")
+            first_protected_method_idx = result.find("def _protected", first_protected_idx)
+            first_public_idx = result.find("def public", first_protected_idx)
+            second_class_idx = result.find("class Second")
+            second_public_idx = result.find("def public", second_class_idx)
+            second_protected_idx = result.find("def _protected", second_class_idx)
+
+            assert first_protected_method_idx < first_public_idx
+            assert second_public_idx < second_protected_idx
+        finally:
+            temp_path.unlink()

{undersort-0.1.3 → undersort-0.1.5}/undersort/__init__.py

@@ -1,3 +1,3 @@
 """undersort - Sort class methods by visibility."""
 
-__version__ = "0.1.3"
+__version__ = "0.1.4"

{undersort-0.1.3 → undersort-0.1.5}/undersort/config.py

@@ -10,11 +10,12 @@ def load_config() -> dict[str, list[str] | None]:
     """Load configuration from pyproject.toml.
 
     Returns:
-        Dictionary with 'order' and 'method_type_order' keys.
+        Dictionary with 'order', 'method_type_order', and 'exclude' keys.
     """
     default_config: dict[str, list[str] | None] = {
         "order": ["public", "protected", "private"],
         "method_type_order": None,
+        "exclude": None,
     }
 
     pyproject_path = _find_pyproject_toml()
@@ -50,6 +51,13 @@ def load_config() -> dict[str, list[str] | None]:
         else:
             result["method_type_order"] = method_type_order
 
+    if "exclude" in config:
+        exclude = config["exclude"]
+        if isinstance(exclude, list):
+            result["exclude"] = exclude
+        else:
+            logger.warning(f"Invalid exclude value in {pyproject_path}. Must be a list.")
+
     return result
 
 

{undersort-0.1.3 → undersort-0.1.5}/undersort/main.py

@@ -1,6 +1,7 @@
 """Main entry point for undersort CLI."""
 
 import argparse
+import fnmatch
 import sys
 from pathlib import Path
 
@@ -9,12 +10,13 @@ from undersort.config import load_config
 from undersort.sorter import sort_file
 
 
-def collect_python_files(path: Path, recursive: bool = True) -> list[Path]:
+def collect_python_files(path: Path, recursive: bool = True, exclude_patterns: list[str] | None = None) -> list[Path]:
     """Collect Python files from a path (file or directory).
 
     Args:
         path: File or directory path
         recursive: If True, recursively search directories
+        exclude_patterns: List of glob patterns to exclude (e.g., ["tests/*", "migrations/*.py"])
 
     Returns:
         List of Python file paths
@@ -37,12 +39,47 @@ def collect_python_files(path: Path, recursive: bool = True) -> list[Path]:
             if not any(part in exclude_dirs or (part.startswith(".") and part != ".") for part in f.parts)
         ]
 
+        if exclude_patterns:
+            filtered_files = [f for f in filtered_files if not _matches_any_pattern(f, exclude_patterns)]
+
         return sorted(filtered_files)
 
     return []
 
 
-def main() -> int:
+def _matches_any_pattern(file_path: Path, patterns: list[str]) -> bool:
+    """Check if a file matches any of the exclusion patterns.
+
+    Args:
+        file_path: Path to check
+        patterns: List of glob patterns
+
+    Returns:
+        True if file matches any pattern, False otherwise
+    """
+    path_str = str(file_path)
+
+    for pattern in patterns:
+        if fnmatch.fnmatch(path_str, pattern):
+            return True
+
+        if "/" not in pattern:
+            if fnmatch.fnmatch(file_path.name, pattern):
+                return True
+            continue
+
+        if fnmatch.fnmatch(path_str, f"*/{pattern}"):
+            return True
+
+        for part_idx in range(len(file_path.parts)):
+            subpath = str(Path(*file_path.parts[part_idx:]))
+            if fnmatch.fnmatch(subpath, pattern):
+                return True
+
+    return False
+
+
+def main() -> int:  # noqa: PLR0912
     """Main entry point for undersort."""
     parser = argparse.ArgumentParser(description="Sort class methods by visibility (public, protected, private)")
     parser.add_argument(
@@ -68,18 +105,30 @@ def main() -> int:
         default=True,
         help="Don't recursively search directories",
     )
+    parser.add_argument(
+        "--exclude",
+        action="append",
+        help="Exclude files/directories matching pattern (can be used multiple times)",
+    )
 
     args = parser.parse_args()
 
     config = load_config()
 
+    exclude_patterns: list[str] = []
+    config_exclude = config.get("exclude")
+    if config_exclude:
+        exclude_patterns.extend(config_exclude)
+    if args.exclude:
+        exclude_patterns.extend(args.exclude)
+
     all_files: list[Path] = []
     for path in args.paths:
         if not path.exists():
             logger.error(f"Path not found: {path}")
             continue
 
-        python_files = collect_python_files(path, args.recursive)
+        python_files = collect_python_files(path, args.recursive, exclude_patterns or None)
         all_files.extend(python_files)
 
     if not all_files:

{undersort-0.1.3 → undersort-0.1.5}/undersort/sorter.py

@@ -9,6 +9,46 @@ import libcst as cst
 from undersort import logger
 
 
+def has_nosort_comment(node: cst.FunctionDef | cst.ClassDef) -> bool:
+    """Check if a node has a nosort comment.
+
+    Args:
+        node: The node to check
+
+    Returns:
+        True if the node has a # nosort comment
+    """
+    if hasattr(node, "leading_lines"):
+        for line in node.leading_lines:
+            if isinstance(line, cst.EmptyLine) and line.comment and "nosort" in line.comment.value.lower():
+                return True
+
+    return bool(
+        hasattr(node, "body")
+        and hasattr(node.body, "header")
+        and isinstance(node.body.header, cst.TrailingWhitespace)
+        and node.body.header.comment
+        and "nosort" in node.body.header.comment.value.lower()
+    )
+
+
+def file_has_nosort(module: cst.Module) -> bool:
+    """Check if a file has a file-level nosort directive.
+
+    Args:
+        module: The module to check
+
+    Returns:
+        True if the file has a # nosort: file comment
+    """
+    for line in module.header:
+        if isinstance(line, cst.EmptyLine) and line.comment:
+            comment_text = line.comment.value.lower()
+            if "nosort" in comment_text and "file" in comment_text:
+                return True
+    return False
+
+
 def get_method_visibility(method_name: str) -> Literal["public", "private", "protected"]:
     """Determine method visibility based on naming convention.
 
@@ -71,7 +111,9 @@ class MethodSorter(cst.CSTTransformer):
         self.modified = False
 
     def leave_ClassDef(  # noqa: PLR0912, PLR0915
-        self, original_node: cst.ClassDef, updated_node: cst.ClassDef
+        self,
+        original_node: cst.ClassDef,
+        updated_node: cst.ClassDef,  # noqa: ARG002
     ) -> cst.ClassDef:
         """Sort methods within a class definition.
 
@@ -82,6 +124,9 @@ class MethodSorter(cst.CSTTransformer):
         Returns:
             ClassDef with sorted methods
         """
+        if has_nosort_comment(updated_node):
+            return updated_node
+
         methods = []
         non_methods = []
 
@@ -94,7 +139,17 @@ class MethodSorter(cst.CSTTransformer):
         if not methods:
             return updated_node
 
-        method_with_index = [(i, method) for i, method in enumerate(methods)]
+        sortable_methods = []
+        nosort_methods = []
+
+        for i, method in enumerate(methods):
+            if has_nosort_comment(method):
+                nosort_methods.append((i, method))
+            else:
+                sortable_methods.append((i, method))
+
+        if not sortable_methods:
+            return updated_node
 
         method_groups: dict[str, dict[str, list[tuple[int, cst.FunctionDef]]]] = {
             "public": {"class": [], "static": [], "instance": []},
@@ -102,7 +157,7 @@ class MethodSorter(cst.CSTTransformer):
             "private": {"class": [], "static": [], "instance": []},
         }
 
-        for idx, method in method_with_index:
+        for idx, method in sortable_methods:
             visibility = get_method_visibility(method.name.value)
             method_type = get_method_type(method)
             method_groups[visibility][method_type].append((idx, method))
@@ -145,9 +200,15 @@ class MethodSorter(cst.CSTTransformer):
 
             current_position += len(group)
 
-        if methods != sorted_methods:
+        all_sorted = sorted_methods[:]
+        for orig_idx, nosort_method in sorted(nosort_methods, key=lambda x: x[0]):
+            all_sorted.insert(orig_idx, nosort_method)
+
+        if methods != all_sorted:
             self.modified = True
 
+        sorted_methods = all_sorted
+
         leading_non_methods = []
         trailing_non_methods = []
         found_method = False
@@ -193,6 +254,9 @@ def sort_file(
     except cst.ParserSyntaxError as e:
         raise ValueError(f"Syntax error in {file_path}: {e}")
 
+    if file_has_nosort(tree):
+        return False
+
     sorter = MethodSorter(order, method_type_order)
     new_tree = tree.visit(sorter)
 

{undersort-0.1.3 → undersort-0.1.5}/uv.lock

@@ -905,7 +905,7 @@ wheels = [
 
 [[package]]
 name = "undersort"
-version = "0.1.3"
+version = "0.1.5"
 source = { editable = "." }
 dependencies = [
     { name = "libcst", version = "1.1.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.9'" },