skylos 1.2.2__py3-none-any.whl → 2.1.0__py3-none-any.whl

test/test_codemods.py

@@ -0,0 +1,153 @@
+import textwrap
+from skylos.codemods import (
+    remove_unused_import_cst,
+    remove_unused_function_cst,
+)
+
+def _line_no(code: str, startswith: str) -> int:
+    for i, line in enumerate(code.splitlines(), start=1):
+        if line.lstrip().startswith(startswith):
+            return i
+    raise AssertionError(f"Line starting with {startswith!r} not found")
+
+def test_remove_simple_import_entire_line():
+    code = "import os\nprint(1)\n"
+    ln = _line_no(code, "import os")
+    new, changed = remove_unused_import_cst(code, "os", ln)
+    assert changed is True
+    assert "import os" not in new
+    assert "print(1)" in new
+
+def test_remove_one_name_from_multi_import():
+    code = "import os, sys\n"
+    ln = _line_no(code, "import os, sys")
+    new, changed = remove_unused_import_cst(code, "os", ln)
+    assert changed is True
+    assert new.strip() == "import sys"
+
+def test_remove_from_import_keeps_other_names():
+    code = "from a import b, c\n"
+    ln = _line_no(code, "from a import")
+    new, changed = remove_unused_import_cst(code, "b", ln)
+    assert changed is True
+    assert new.strip() == "from a import c"
+
+def test_remove_from_import_with_alias_uses_bound_name():
+    code = "from a import b as c, d\n"
+    ln = _line_no(code, "from a import")
+    new, changed = remove_unused_import_cst(code, "c", ln)
+    assert changed is True
+    assert new.strip() == "from a import d"
+
+def test_parenthesized_multiline_from_import_preserves_formatting():
+    code = textwrap.dedent(
+        """\
+        from x.y import (
+            a,
+            b,  # keep me
+            c,
+        )
+        use = b
+        """
+    )
+    ln = _line_no(code, "from x.y import")
+    new, changed = remove_unused_import_cst(code, "a", ln)
+    assert changed is True
+    assert "a," not in new
+    assert "b,  # keep me" in new
+    assert "c," in new
+
+def test_import_star_is_noop():
+    code = "from x import *\n"
+    ln = _line_no(code, "from x import *")
+    new, changed = remove_unused_import_cst(code, "*", ln)
+    assert changed is False
+    assert new == code
+
+def test_dotted_import_requires_bound_leftmost_segment():
+    code = "import pkg.sub\n"
+    ln = _line_no(code, "import pkg.sub")
+    new, changed = remove_unused_import_cst(code, "pkg", ln)
+    assert changed is True
+    assert "import pkg.sub" not in new
+
+    new2, changed2 = remove_unused_import_cst(code, "sub", ln)
+    assert changed2 is False
+    assert new2 == code
+
+def test_import_idempotency():
+    code = "import os, sys\n"
+    ln = _line_no(code, "import os, sys")
+    new, changed = remove_unused_import_cst(code, "os", ln)
+    assert changed is True
+    new2, changed2 = remove_unused_import_cst(new, "os", ln)
+    assert changed2 is False
+    assert new2 == new
+
+def test_remove_simple_function_block():
+    code = textwrap.dedent(
+        """\
+        def unused():
+            x = 1
+            return x
+
+        def used():
+            return 42
+        """
+    )
+    ln = _line_no(code, "def unused")
+    new, changed = remove_unused_function_cst(code, "unused", ln)
+    assert changed is True
+    assert "def unused" not in new
+    assert "def used" in new
+
+def test_remove_decorated_function_removes_decorators_too():
+    code = textwrap.dedent(
+        """\
+        @dec1
+        @dec2(arg=1)
+        def target():
+            return 1
+
+        def other():
+            return 2
+        """
+    )
+    ln = _line_no(code, "def target")
+    new, changed = remove_unused_function_cst(code, "target", ln)
+    assert changed is True
+    assert "@dec1" not in new and "@dec2" not in new
+    assert "def target" not in new
+    assert "def other" in new
+
+def test_remove_async_function():
+    code = textwrap.dedent(
+        """\
+        async def coro():
+            return 1
+
+        def ok():
+            return 2
+        """
+    )
+    ln = _line_no(code, "async def coro")
+    new, changed = remove_unused_function_cst(code, "coro", ln)
+    assert changed is True
+    assert "async def coro" not in new
+    assert "def ok" in new
+
+def test_function_wrong_line_noop():
+    code = "def f():\n    return 1\n"
+    ln = 999
+    new, changed = remove_unused_function_cst(code, "f", ln)
+    assert changed is False
+    assert new == code
+
+def test_function_idempotency():
+    code = "def g():\n    return 1\n"
+    ln = _line_no(code, "def g")
+    new, changed = remove_unused_function_cst(code, "g", ln)
+    assert changed is True
+    new2, changed2 = remove_unused_function_cst(new, "g", ln)
+    assert changed2 is False
+    assert new2 == new

test/test_framework_aware.py

@@ -1,80 +1,60 @@
 #!/usr/bin/env python3
 import pytest
 import ast
-from pathlib import Path
 from unittest.mock import Mock, patch
-import fnmatch
 
-try:
-    from skylos.framework_aware import (
-        FrameworkAwareVisitor, 
+from skylos.framework_aware import (
+        FrameworkAwareVisitor,
         detect_framework_usage,
         FRAMEWORK_DECORATORS,
         FRAMEWORK_FUNCTIONS,
-        FRAMEWORK_IMPORTS
-    )
-except ImportError:
-    import sys
-    from pathlib import Path
-    sys.path.insert(0, str(Path(__file__).parent.parent))
-    from skylos.framework_aware import (
-        FrameworkAwareVisitor, 
-        detect_framework_usage,
-        FRAMEWORK_DECORATORS,
-        FRAMEWORK_FUNCTIONS,
-        FRAMEWORK_IMPORTS
+        FRAMEWORK_IMPORTS,
     )
 
 class TestFrameworkAwareVisitor:
-    
     def test_init_default(self):
-        """Test default initialization"""
-        visitor = FrameworkAwareVisitor()
-        assert visitor.is_framework_file == False
-        assert visitor.framework_decorated_lines == set()
-        assert visitor.detected_frameworks == set()
-    
+        v = FrameworkAwareVisitor()
+        assert v.is_framework_file is False
+        assert v.framework_decorated_lines == set()
+        assert v.detected_frameworks == set()
+
     def test_flask_import_detection(self):
-        """Test Flask import detection"""
         code = """
 import flask
 from flask import Flask, request
 """
         tree = ast.parse(code)
-        visitor = FrameworkAwareVisitor()
-        visitor.visit(tree)
-        
-        assert visitor.is_framework_file == True
-        assert 'flask' in visitor.detected_frameworks
-    
+        v = FrameworkAwareVisitor()
+        v.visit(tree)
+        v.finalize()
+        assert v.is_framework_file is True
+        assert "flask" in v.detected_frameworks
+
     def test_fastapi_import_detection(self):
-        """Test FastAPI import detection"""
         code = """
 from fastapi import FastAPI
 import fastapi
 """
         tree = ast.parse(code)
-        visitor = FrameworkAwareVisitor()
-        visitor.visit(tree)
-        
-        assert visitor.is_framework_file == True
-        assert 'fastapi' in visitor.detected_frameworks
-    
+        v = FrameworkAwareVisitor()
+        v.visit(tree)
+        v.finalize()
+        assert v.is_framework_file is True
+        assert "fastapi" in v.detected_frameworks
+
     def test_django_import_detection(self):
-        """Test Django import detection"""
         code = """
 from django.http import HttpResponse
 from django.views import View
 """
         tree = ast.parse(code)
-        visitor = FrameworkAwareVisitor()
-        visitor.visit(tree)
-        
-        assert visitor.is_framework_file == True
-        assert 'django' in visitor.detected_frameworks
-    
+        v = FrameworkAwareVisitor()
+        v.visit(tree)
+        v.finalize()
+        assert v.is_framework_file is True
+        assert "django" in v.detected_frameworks
+
     def test_flask_route_decorator_detection(self):
-        """Test Flask route decorator detection"""
         code = """
 @app.route('/api/users')
 def get_users():
@@ -85,15 +65,14 @@ def create_user():
     return {}
 """
         tree = ast.parse(code)
-        visitor = FrameworkAwareVisitor()
-        visitor.visit(tree)
-        
-        assert visitor.is_framework_file == True
-        assert 3 in visitor.framework_decorated_lines  # get_users function
-        assert 7 in visitor.framework_decorated_lines  # create_user function
-    
+        v = FrameworkAwareVisitor()
+        v.visit(tree)
+        v.finalize()
+        assert v.is_framework_file is True
+        assert 3 in v.framework_decorated_lines
+        assert 7 in v.framework_decorated_lines
+
     def test_fastapi_router_decorator_detection(self):
-        """Test FastAPI router decorator detection"""
         code = """
 @router.get('/items')
 async def read_items():
@@ -104,15 +83,14 @@ async def create_item():
     return {}
 """
         tree = ast.parse(code)
-        visitor = FrameworkAwareVisitor()
-        visitor.visit(tree)
-        
-        assert visitor.is_framework_file == True
-        assert 3 in visitor.framework_decorated_lines
-        assert 7 in visitor.framework_decorated_lines
-    
+        v = FrameworkAwareVisitor()
+        v.visit(tree)
+        v.finalize()
+        assert v.is_framework_file is True
+        assert 3 in v.framework_decorated_lines
+        assert 7 in v.framework_decorated_lines
+
     def test_django_decorator_detection(self):
-        """Test Django decorator detection"""
         code = """
 @login_required
 def protected_view(request):
@@ -123,34 +101,14 @@ def admin_view(request):
     return HttpResponse("Admin")
 """
         tree = ast.parse(code)
-        visitor = FrameworkAwareVisitor()
-        visitor.visit(tree)
-        
-        assert visitor.is_framework_file == True
-        assert 3 in visitor.framework_decorated_lines
-        assert 7 in visitor.framework_decorated_lines
-    
-    def test_celery_task_decorator_detection(self):
-        """Test Celery task decorator detection"""
-        code = """
-@task
-def background_task():
-    return "done"
+        v = FrameworkAwareVisitor()
+        v.visit(tree)
+        v.finalize()
+        assert v.is_framework_file is True
+        assert 3 in v.framework_decorated_lines
+        assert 7 in v.framework_decorated_lines
 
-@shared_task
-def shared_background_task():
-    return "shared done"
-"""
-        tree = ast.parse(code)
-        visitor = FrameworkAwareVisitor()
-        visitor.visit(tree)
-        
-        assert visitor.is_framework_file == True
-        assert 3 in visitor.framework_decorated_lines
-        assert 7 in visitor.framework_decorated_lines
-    
     def test_django_view_class_detection(self):
-        """Test Django view class detection"""
         code = """
 from django import views
 
@@ -163,55 +121,29 @@ class UserViewSet(ViewSet):
         return Response([])
 """
         tree = ast.parse(code)
-        visitor = FrameworkAwareVisitor()
-        visitor.visit(tree)
-        
-        assert visitor.is_framework_file == True
-        assert 4 in visitor.framework_decorated_lines
-        assert 8 in visitor.framework_decorated_lines
-    
-    def test_django_model_methods_in_framework_file(self):
-        code = """
-from django.db import models
-
-class User(models.Model):
-    name = models.CharField(max_length=100)
-    
-    def save(self, *args, **kwargs):
-        # custom save logic
-        super().save(*args, **kwargs)
-    
-    def delete(self, *args, **kwargs):
-        # custom delete logic
-        super().delete(*args, **kwargs)
-"""
-        tree = ast.parse(code)
-        visitor = FrameworkAwareVisitor()
-        visitor.visit(tree)
-        
-        assert visitor.is_framework_file == True
-        assert 7 in visitor.framework_decorated_lines  # save method
-        assert 11 in visitor.framework_decorated_lines  # delete method
-    
+        v = FrameworkAwareVisitor()
+        v.visit(tree)
+        v.finalize()
+        assert v.is_framework_file is True
+        assert 5 in v.framework_decorated_lines
+        assert 9 in v.framework_decorated_lines
+
     def test_framework_functions_not_detected_in_non_framework_file(self):
         code = """
 def save(self):
-    # regular save method, not Django
     pass
 
 def get(self):
-    # regular get method, not Django view
     pass
 """
         tree = ast.parse(code)
-        visitor = FrameworkAwareVisitor()
-        visitor.visit(tree)
-        
-        assert visitor.is_framework_file == False
-        assert visitor.framework_decorated_lines == set()
-    
+        v = FrameworkAwareVisitor()
+        v.visit(tree)
+        v.finalize()
+        assert v.is_framework_file is False
+        assert v.framework_decorated_lines == set()
+
     def test_multiple_decorators(self):
-        """Test function with multiple decorators"""
         code = """
 @app.route('/users')
 @login_required
@@ -220,14 +152,13 @@ def get_users():
     return []
 """
         tree = ast.parse(code)
-        visitor = FrameworkAwareVisitor()
-        visitor.visit(tree)
-        
-        assert visitor.is_framework_file == True
-        assert 5 in visitor.framework_decorated_lines
-    
+        v = FrameworkAwareVisitor()
+        v.visit(tree)
+        v.finalize()
+        assert v.is_framework_file is True
+        assert 5 in v.framework_decorated_lines
+
     def test_complex_decorator_patterns(self):
-        """Test complex decorator patterns"""
         code = """
 @app.route('/api/v1/users/<int:user_id>', methods=['GET', 'POST'])
 def user_endpoint(user_id):
@@ -238,135 +169,138 @@ async def get_item(item_id: int):
     return {}
 """
         tree = ast.parse(code)
-        visitor = FrameworkAwareVisitor()
-        visitor.visit(tree)
-        
-        assert visitor.is_framework_file == True
-        assert 3 in visitor.framework_decorated_lines
-        assert 7 in visitor.framework_decorated_lines
-    
-    @patch('skylos.framework_aware.Path')
+        v = FrameworkAwareVisitor()
+        v.visit(tree)
+        v.finalize()
+        assert v.is_framework_file is True
+        assert 3 in v.framework_decorated_lines
+        assert 7 in v.framework_decorated_lines
+
+    @patch("skylos.framework_aware.Path")
     def test_file_content_framework_detection(self, mock_path):
-        """Test framework detection from file content"""
         mock_file = Mock()
         mock_file.read_text.return_value = "from flask import Flask\napp = Flask(__name__)"
         mock_path.return_value = mock_file
-        
-        visitor = FrameworkAwareVisitor(filename="test.py")
-        
-        assert visitor.is_framework_file == True
-        assert 'flask' in visitor.detected_frameworks
-    
+        v = FrameworkAwareVisitor(filename="test.py")
+        v.finalize()
+        assert v.is_framework_file is True
+        assert "flask" in v.detected_frameworks
+
     def test_normalize_decorator_name(self):
-        visitor = FrameworkAwareVisitor()
-        
+        v = FrameworkAwareVisitor()
         node = ast.parse("@decorator\ndef func(): pass").body[0].decorator_list[0]
-        result = visitor._normalize_decorator(node)
-        assert result == "@decorator"
-        
+        assert v._normalize_decorator(node) == "@decorator"
         node = ast.parse("@app.route\ndef func(): pass").body[0].decorator_list[0]
-        result = visitor._normalize_decorator(node)
-        assert result == "@app.route"
+        assert v._normalize_decorator(node) == "@app.route"
+
+    def test_depends_marks_dependency_and_flags_framework_file(self):
+        code = """
+from fastapi import Depends
+
+def dep():
+    return 1
+
+@router.get("/")
+def foo(x: int = Depends(dep)):
+    return {}
+"""
+        tree = ast.parse(code)
+        v = FrameworkAwareVisitor()
+        v.visit(tree)
+        v.finalize()
+        assert v.is_framework_file is True
+        assert 4 in v.framework_decorated_lines
+
+    def test_typed_model_in_route_marks_model_definition(self):
+        code = """
+from pydantic import BaseModel
+
+class In(BaseModel):
+    x: int
+
+@router.post("/")
+def calc(req: In):
+    return 1
+"""
+        tree = ast.parse(code)
+        v = FrameworkAwareVisitor()
+        v.visit(tree)
+        v.finalize()
+        assert v.is_framework_file is True
+        assert 4 in v.framework_decorated_lines
 
 class TestDetectFrameworkUsage:
-    
-    def test_framework_decorated_function_low_confidence(self):
-        mock_def = Mock()
-        mock_def.line = 10
-        mock_def.simple_name = "get_users"
-        mock_def.type = "function"
-        
-        mock_visitor = Mock()
-        mock_visitor.framework_decorated_lines = {10}
-        mock_visitor.is_framework_file = True
-        
-        confidence = detect_framework_usage(mock_def, visitor=mock_visitor)
-        assert confidence == 20
-    
-    def test_framework_file_function_medium_confidence(self):
-        mock_def = Mock()
-        mock_def.line = 15
-        mock_def.simple_name = "helper_function"
-        mock_def.type = "function"
-        
-        mock_visitor = Mock()
-        mock_visitor.framework_decorated_lines = set()
-        mock_visitor.is_framework_file = True
-        
-        confidence = detect_framework_usage(mock_def, visitor=mock_visitor)
-        assert confidence == 40
-    
-    def test_private_function_in_framework_file_no_confidence(self):
-        mock_def = Mock()
-        mock_def.line = 20
-        mock_def.simple_name = "_private_function"
-        mock_def.type = "function"
-        
-        mock_visitor = Mock()
-        mock_visitor.framework_decorated_lines = set()
-        mock_visitor.is_framework_file = True
-        
-        confidence = detect_framework_usage(mock_def, visitor=mock_visitor)
-        assert confidence is None
-    
-    def test_non_framework_file_no_confidence(self):
-        mock_def = Mock()
-        mock_def.line = 25
-        mock_def.simple_name = "regular_function"
-        mock_def.type = "function"
-        
-        mock_visitor = Mock()
-        mock_visitor.framework_decorated_lines = set()
-        mock_visitor.is_framework_file = False
-        
-        confidence = detect_framework_usage(mock_def, visitor=mock_visitor)
-        assert confidence is None
-    
+    def test_decorated_endpoint_confidence_is_one(self):
+        d = Mock()
+        d.line = 10
+        d.simple_name = "get_users"
+        d.type = "function"
+        v = Mock()
+        v.framework_decorated_lines = {10}
+        v.is_framework_file = True
+        assert detect_framework_usage(d, visitor=v) == 1
+
+    def test_undecorated_function_in_framework_file_returns_none(self):
+        d = Mock()
+        d.line = 15
+        d.simple_name = "helper_function"
+        d.type = "function"
+        v = Mock()
+        v.framework_decorated_lines = set()
+        v.is_framework_file = True
+        assert detect_framework_usage(d, visitor=v) is None
+
+    def test_private_function_in_framework_file_returns_none(self):
+        d = Mock()
+        d.line = 20
+        d.simple_name = "_private_function"
+        d.type = "function"
+        v = Mock()
+        v.framework_decorated_lines = set()
+        v.is_framework_file = True
+        assert detect_framework_usage(d, visitor=v) is None
+
+    def test_non_framework_file_returns_none(self):
+        d = Mock()
+        d.line = 25
+        d.simple_name = "regular_function"
+        d.type = "function"
+        v = Mock()
+        v.framework_decorated_lines = set()
+        v.is_framework_file = False
+        assert detect_framework_usage(d, visitor=v) is None
+
     def test_no_visitor_returns_none(self):
-        mock_def = Mock()
-        confidence = detect_framework_usage(mock_def, visitor=None)
-        assert confidence is None
-    
-    def test_non_function_in_framework_file_no_confidence(self):
-        mock_def = Mock()
-        mock_def.line = 30
-        mock_def.simple_name = "my_variable"
-        mock_def.type = "variable"
-        
-        mock_visitor = Mock()
-        mock_visitor.framework_decorated_lines = set()
-        mock_visitor.is_framework_file = True
-        
-        confidence = detect_framework_usage(mock_def, visitor=mock_visitor)
-        assert confidence is None
+        d = Mock()
+        assert detect_framework_usage(d, visitor=None) is None
 
+    def test_non_function_in_framework_file_returns_none(self):
+        d = Mock()
+        d.line = 30
+        d.simple_name = "my_variable"
+        d.type = "variable"
+        v = Mock()
+        v.framework_decorated_lines = set()
+        v.is_framework_file = True
+        assert detect_framework_usage(d, visitor=v) is None
 
 class TestFrameworkPatterns:
-    
     def test_framework_decorators_list(self):
-        """Test that FRAMEWORK_DECORATORS contains expected patterns"""
-        assert "@app.route" in FRAMEWORK_DECORATORS
-        assert "@router.get" in FRAMEWORK_DECORATORS
+        assert "@*.route" in FRAMEWORK_DECORATORS
+        assert "@*.get" in FRAMEWORK_DECORATORS
         assert "@login_required" in FRAMEWORK_DECORATORS
-        assert "@task" in FRAMEWORK_DECORATORS
-        assert "@validator" in FRAMEWORK_DECORATORS
-    
+
     def test_framework_functions_list(self):
-        """Test that FRAMEWORK_FUNCTIONS contains expected patterns"""
         assert "get" in FRAMEWORK_FUNCTIONS
         assert "post" in FRAMEWORK_FUNCTIONS
-        assert "save" in FRAMEWORK_FUNCTIONS
         assert "*_queryset" in FRAMEWORK_FUNCTIONS
         assert "get_context_data" in FRAMEWORK_FUNCTIONS
-    
-    def test_framework_imports_set(self):
-        """Test that FRAMEWORK_IMPORTS contains expected frameworks"""
-        assert 'flask' in FRAMEWORK_IMPORTS
-        assert 'django' in FRAMEWORK_IMPORTS
-        assert 'fastapi' in FRAMEWORK_IMPORTS
-        assert 'celery' in FRAMEWORK_IMPORTS
-        assert 'pydantic' in FRAMEWORK_IMPORTS
 
+    def test_framework_imports_set(self):
+        assert "flask" in FRAMEWORK_IMPORTS
+        assert "django" in FRAMEWORK_IMPORTS
+        assert "fastapi" in FRAMEWORK_IMPORTS
+        assert "pydantic" in FRAMEWORK_IMPORTS
 
 if __name__ == "__main__":
     pytest.main([__file__, "-v"])