skylos 1.1.12__py3-none-any.whl → 1.2.0__py3-none-any.whl

skylos/visitor.py

@@ -1,6 +1,11 @@
 #!/usr/bin/env python3
 import ast
 from pathlib import Path
+import os 
+import re, logging, traceback
+DBG = bool(int(os.getenv("SKYLOS_DEBUG", "0")))
+log = logging.getLogger("Skylos")
+
 
 PYTHON_BUILTINS={"print","len","str","int","float","list","dict","set","tuple","range","open","super","object","type","enumerate","zip","map","filter","sorted","reversed","sum","min","max","all","any","next","iter","repr","chr","ord","bytes","bytearray","memoryview","format","round","abs","pow","divmod","complex","hash","id","bool","callable","getattr","setattr","delattr","hasattr","isinstance","issubclass","globals","locals","vars","dir","property","classmethod","staticmethod"}
 DYNAMIC_PATTERNS={"getattr","globals","eval","exec"}
@@ -74,11 +79,23 @@ class Visitor(ast.NodeVisitor):
                 self.visit(node)
 
     def visit_string_annotation(self, annotation_str):
+        if not isinstance(annotation_str, str):
+            return
+
+        if DBG:
+            log.debug(f"[visitor] parsing string annotation {annotation_str!r} "
+                    f"in {self.filename}:{getattr(self, 'line', '?')}")
+
         try:
-            parsed = ast.parse(annotation_str, mode='eval')
+            parsed = ast.parse(annotation_str, mode="eval")
             self.visit(parsed.body)
-        except:
-            pass
+        except Exception:
+            if DBG:
+                log.debug("[visitor] inner-annotation parse failed:\n" +
+                        traceback.format_exc())
+            # keep going but dont swallow symbol names:
+            for tok in re.findall(r"[A-Za-z_][A-Za-z0-9_]*", annotation_str):
+                self.add_ref(tok)
 
     def visit_Import(self,node):
         for a in node.names:
@@ -250,6 +267,11 @@ class Visitor(ast.NodeVisitor):
                     if module_name != "self": 
                         qualified_name = f"{self.qual(module_name)}.{attr_name}"
                         self.add_ref(qualified_name)
+            
+            elif isinstance(node.args[0], ast.Name):
+                target_name = node.args[0].id
+                if target_name != "self":
+                    self.dyn.add(self.mod.split(".")[0] if self.mod else "")
         
         elif isinstance(node.func, ast.Name) and node.func.id == "globals":
             parent = getattr(node, 'parent', None)
@@ -259,6 +281,9 @@ class Visitor(ast.NodeVisitor):
                 func_name = parent.slice.value
                 self.add_ref(func_name)
                 self.add_ref(f"{self.mod}.{func_name}")
+        
+        elif isinstance(node.func, ast.Name) and node.func.id in ("eval", "exec"):
+            self.dyn.add(self.mod.split(".")[0] if self.mod else "")
 
     def visit_Name(self,node):
         if isinstance(node.ctx,ast.Load):

{skylos-1.1.12.dist-info → skylos-1.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: skylos
-Version: 1.1.12
+Version: 1.2.0
 Summary: A static analysis tool for Python codebases
 Author-email: oha <aaronoh2015@gmail.com>
 Requires-Python: >=3.9

skylos-1.2.0.dist-info/RECORD

@@ -0,0 +1,32 @@
+skylos/__init__.py,sha256=ZZWhq0TZ3G-yDi9inbYvMn8OBes-pqo1aYB5EivuxFI,152
+skylos/analyzer.py,sha256=MVO16T58bPpcISQKiHWtcQaeHG6r2awH6IuxHUmG56E,13858
+skylos/cli.py,sha256=6udZY4vLU6PFzVMkaiCLCRcLXgquyHdmf4rIOAPosWc,18266
+skylos/constants.py,sha256=F1kMjuTxfw2hJjd0SeOQcgex5WhHMUhXCzOlVmwuACs,1230
+skylos/framework_aware.py,sha256=p7BGoFnzkpaLJoE3M5qgyIeZvXx17tOkdyXgeqGKmqU,5804
+skylos/test_aware.py,sha256=cduaWMcFsuzIEQWAMFPC58xGk8NUU3SbUS0ChRPedv8,2372
+skylos/visitor.py,sha256=MnWyzs0b2JOD2Nj1Iu7ZIZHCr7fRC92PY1bsT8bdgXg,12796
+test/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+test/compare_tools.py,sha256=0g9PDeJlbst-7hOaQzrL4MiJFQKpqM8q8VeBGzpPczg,22738
+test/conftest.py,sha256=57sTF6vLL5U0CVKwGQFJcRs6n7t1dEHIriQoSluNmAI,6418
+test/diagnostics.py,sha256=ExuFOCVpc9BDwNYapU96vj9RXLqxji32Sv6wVF4nJYU,13802
+test/test_analyzer.py,sha256=c8gbZuUls3N8xGGDXdPzsaoma6AFR2fIDqp9cNJlg7c,22104
+test/test_changes_analyzer.py,sha256=l1hspCFz-sF8gqOilJvntUDuGckwhYsVtzvSRB13ZWw,5085
+test/test_cli.py,sha256=rtdKzanDRJT_F92jKkCQFdhvlfwVJxfXKO8Hrbn-mIg,13180
+test/test_constants.py,sha256=pMuDy0UpC81zENMDCeK6Bqmm3BR_HHZQSlMG-9TgOm0,12602
+test/test_framework_aware.py,sha256=tJ7bnhiGeSdsAvrWaGJO5ovTrw9n9BBk6o1HCw15yDA,11693
+test/test_integration.py,sha256=bNKGUe-w0xEZEdnoQNHbssvKMGs9u9fmFQTOz1lX9_k,12398
+test/test_skylos.py,sha256=kz77STrS4k3Eez5RDYwGxOg2WH3e7zNZPUYEaTLbGTs,15608
+test/test_test_aware.py,sha256=VmbR_MQY0m941CAxxux8OxJHIr7l8crfWRouSeBMhIo,9390
+test/test_visitor.py,sha256=xAbGv-XaozKm_0WJJhr0hMb6mLaJcbPz57G9-SWkxFU,22764
+test/sample_repo/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+test/sample_repo/app.py,sha256=M5XgoAn-LPz50mKAj_ZacRKf-Pg7I4HbjWP7Z9jE4a0,226
+test/sample_repo/sample_repo/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+test/sample_repo/sample_repo/commands.py,sha256=b6gQ9YDabt2yyfqGbOpLo0osF7wya8O4Lm7m8gtCr3g,2575
+test/sample_repo/sample_repo/models.py,sha256=xXIg3pToEZwKuUCmKX2vTlCF_VeFA0yZlvlBVPIy5Qw,3320
+test/sample_repo/sample_repo/routes.py,sha256=8yITrt55BwS01G7nWdESdx8LuxmReqop1zrGUKPeLi8,2475
+test/sample_repo/sample_repo/utils.py,sha256=S56hEYh8wkzwsD260MvQcmUFOkw2EjFU27nMLFE6G2k,1103
+skylos-1.2.0.dist-info/METADATA,sha256=FqeObdsFPYrqrKzpBngriBQbKZXnOJUnqDKJQSn-N4k,224
+skylos-1.2.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+skylos-1.2.0.dist-info/entry_points.txt,sha256=zzRpN2ByznlQoLeuLolS_TFNYSQxUGBL1EXQsAd6bIA,43
+skylos-1.2.0.dist-info/top_level.txt,sha256=f8GA_7KwfaEopPMP8-EXDQXaqd4IbsOQPakZy01LkdQ,12
+skylos-1.2.0.dist-info/RECORD,,

test/test_analyzer.py

@@ -1,36 +1,101 @@
-#!/usr/bin/env python3
 import pytest
 import json
 import tempfile
 from pathlib import Path
 from unittest.mock import Mock, patch
 from collections import defaultdict
+from skylos.test_aware import TestAwareVisitor
+from skylos.framework_aware import FrameworkAwareVisitor
 
-try:
-    from skylos.analyzer import (
-        Skylos, 
-        parse_exclude_folders, 
-        proc_file, 
-        analyze,
-        DEFAULT_EXCLUDE_FOLDERS,
-        AUTO_CALLED,
-        MAGIC_METHODS,
-        TEST_METHOD_PATTERN
-    )
-except ImportError:
-    import sys
-    from pathlib import Path
-    sys.path.insert(0, str(Path(__file__).parent.parent))
-    from skylos.analyzer import (
-        Skylos, 
-        parse_exclude_folders, 
-        proc_file, 
-        analyze,
-        DEFAULT_EXCLUDE_FOLDERS,
-        AUTO_CALLED,
-        MAGIC_METHODS,
-        TEST_METHOD_PATTERN
-    )
+from skylos.analyzer import (
+    Skylos, 
+    parse_exclude_folders, 
+    proc_file, 
+    analyze,
+    DEFAULT_EXCLUDE_FOLDERS,
+)
+
+@pytest.fixture
+def mock_definition():
+    def _create_mock_def(name, simple_name, type, references=0, is_exported=False, confidence=100, in_init=False, line=1):
+        mock = Mock()
+        mock.name = name
+        mock.simple_name = simple_name
+        mock.type = type
+        mock.references = references
+        mock.is_exported = is_exported
+        mock.confidence = confidence
+        mock.in_init = in_init
+        mock.line = line
+        mock.to_dict.return_value = {
+            "name": name,
+            "type": type,
+            "file": "test.py",
+            "line": line
+        }
+        return mock
+    return _create_mock_def
+
+@pytest.fixture
+def mock_test_aware_visitor():
+    mock = Mock(spec=TestAwareVisitor)
+    mock.is_test_file = False
+    mock.test_decorated_lines = set()
+    return mock
+
+@pytest.fixture
+def mock_framework_aware_visitor():
+    mock = Mock(spec=FrameworkAwareVisitor)
+    mock.framework_decorated_lines = set()
+    return mock
+
+@pytest.fixture
+def temp_python_project():
+    """Create a temp Python project for testing"""
+    with tempfile.TemporaryDirectory() as temp_dir:
+        temp_path = Path(temp_dir)
+        
+        main_py = temp_path / "main.py"
+        main_py.write_text("""
+def used_function():
+    return "used"
+
+def unused_function():
+    return "unused"
+
+class UsedClass:
+    def method(self):
+        pass
+
+class UnusedClass:
+    def method(self):
+        pass
+
+result = used_function()
+instance = UsedClass()
+""")
+        
+        package_dir = temp_path / "mypackage"
+        package_dir.mkdir()
+        
+        init_py = package_dir / "__init__.py"
+        init_py.write_text("""
+from .module import exported_function
+
+def internal_function():
+    pass
+""")
+        
+        module_py = package_dir / "module.py"
+        module_py.write_text("""
+def exported_function():
+    return "exported"
+
+def internal_function():
+    return "internal"
+""")
+        
+        yield temp_path
 
 class TestParseExcludeFolders:
     
@@ -66,7 +131,6 @@ class TestParseExcludeFolders:
         assert "custom_folder" not in result
         assert "another_folder" in result
 
-
 class TestSkylos:
     
     @pytest.fixture
@@ -214,7 +278,6 @@ class TestSkylos:
         assert mock_import.references == 1
         assert mock_original.references == 1
 
-
 class TestHeuristics:
     
     @pytest.fixture
@@ -258,136 +321,9 @@ class TestHeuristics:
         
         assert mock_init.references == 1
         assert mock_enter.references == 1
-    
-    def test_magic_methods_confidence_zero(self, mock_definition):
-        """magic methods get confidence of 0."""
-        skylos = Skylos()
-        
-        mock_magic = mock_definition(
-            name="MyClass.__str__",
-            simple_name="__str__",
-            type="method",
-            confidence=100
-        )
-        
-        skylos.defs = {"MyClass.__str__": mock_magic}
-        skylos._apply_heuristics()
-        
-        assert mock_magic.confidence == 0
-    
-    def test_self_cls_parameters_confidence_zero(self, mock_definition):
-        """self/cls parameters get confidence of 0"""
-        skylos = Skylos()
-        
-        mock_self = mock_definition(
-            name="self",
-            simple_name="self",
-            type="parameter",
-            confidence=100
-        )
-        
-        mock_cls = mock_definition(
-            name="cls",
-            simple_name="cls",
-            type="parameter",
-            confidence=100
-        )
-        
-        skylos.defs = {"self": mock_self, "cls": mock_cls}
-        skylos._apply_heuristics()
-        
-        assert mock_self.confidence == 0
-        assert mock_cls.confidence == 0
-    
-    def test_test_methods_confidence_zero(self, mock_definition):
-        """test methods in test classes get confidence of 0"""
-        skylos = Skylos()
-        
-        mock_test_method = mock_definition(
-            name="TestMyClass.test_something",
-            simple_name="test_something",
-            type="method",
-            confidence=100
-        )
-        
-        skylos.defs = {"TestMyClass.test_something": mock_test_method}
-        skylos._apply_heuristics()
-        
-        assert mock_test_method.confidence == 0
-    
-    def test_underscore_variable_confidence_zero(self, mock_definition):
-        """underscore variables get confidence of 0."""
-        skylos = Skylos()
-        
-        mock_underscore = mock_definition(
-            name="_",
-            simple_name="_",
-            type="variable",
-            confidence=100
-        )
-        
-        skylos.defs = {"_": mock_underscore}
-        skylos._apply_heuristics()
-        
-        assert mock_underscore.confidence == 0
-
 
 class TestAnalyze:
     
-    @pytest.fixture
-    def temp_python_project(self):
-        """Create a temp Python project for testing"""
-        with tempfile.TemporaryDirectory() as temp_dir:
-            temp_path = Path(temp_dir)
-            
-            main_py = temp_path / "main.py"
-            main_py.write_text("""
-def used_function():
-    return "used"
-
-def unused_function():
-    return "unused"
-
-class UsedClass:
-    def method(self):
-        pass
-
-class UnusedClass:
-    def method(self):
-        pass
-
-result = used_function()
-instance = UsedClass()
-""")
-            
-            package_dir = temp_path / "mypackage"
-            package_dir.mkdir()
-            
-            init_py = package_dir / "__init__.py"
-            init_py.write_text("""
-from .module import exported_function
-
-def internal_function():
-    pass
-""")
-            
-            module_py = package_dir / "module.py"
-            module_py.write_text("""
-def exported_function():
-    return "exported"
-
-def internal_function():
-    return "internal"
-""")
-            
-            test_dir = temp_path / "__pycache__"
-            test_dir.mkdir()
-            
-            test_file = test_dir / "cached.pyc"
-            test_file.write_text("# This should be excluded")
-            
-            yield temp_path
-    
     @patch('skylos.analyzer.proc_file')
     def test_analyze_basic(self, mock_proc_file, temp_python_project):
         mock_def = Mock()
@@ -398,18 +334,26 @@ def internal_function():
         mock_def.type = "function"
         mock_def.to_dict.return_value = {
             "name": "test.unused_function",
-            "type": "function",
+            "type": "function", 
             "file": "test.py",
             "line": 1
         }
         
-        mock_proc_file.return_value = ([mock_def], [], set(), set())
+        mock_test_visitor = Mock(spec=TestAwareVisitor)
+        mock_test_visitor.is_test_file = False
+        mock_test_visitor.test_decorated_lines = set()
+        
+        mock_framework_visitor = Mock(spec=FrameworkAwareVisitor)
+        mock_framework_visitor.framework_decorated_lines = set()
+        mock_framework_visitor.is_framework_file = False
+        
+        mock_proc_file.return_value = ([mock_def], [], set(), set(), mock_test_visitor, mock_framework_visitor)
         
         result_json = analyze(str(temp_python_project), conf=60)
         result = json.loads(result_json)
         
         assert "unused_functions" in result
-        assert "unused_imports" in result
+        assert "unused_imports" in result  
         assert "unused_classes" in result
         assert "unused_variables" in result
         assert "unused_parameters" in result
@@ -422,7 +366,7 @@ def internal_function():
         exclude_file = exclude_dir / "generated.py"
         exclude_file.write_text("def generated_function(): pass")
         
-        result_json = analyze(str(temp_python_project), exclude_folders=["build"])  # Use list instead of set
+        result_json = analyze(str(temp_python_project), exclude_folders=["build"])
         result = json.loads(result_json)
         
         assert result["analysis_summary"]["excluded_folders"] == ["build"]
@@ -466,7 +410,7 @@ def internal_function():
             mock_get_files.return_value = ([Path("/fake/file.py")], Path("/"))
             
             with patch('skylos.analyzer.proc_file') as mock_proc_file:
-                mock_proc_file.return_value = ([], [], set(), set())
+                mock_proc_file.return_value = ([], [], set(), set(), Mock(spec=TestAwareVisitor), Mock(spec=FrameworkAwareVisitor))
                 
                 result_json = skylos.analyze("/fake/path", thr=60)
                 result = json.loads(result_json)
@@ -475,7 +419,6 @@ def internal_function():
                 assert len(result["unused_functions"]) == 1
                 assert result["unused_functions"][0]["name"] == "high_conf"
 
-
 class TestProcFile:
     
     def test_proc_file_with_valid_python(self):
@@ -491,7 +434,10 @@ class TestClass:
             f.flush()
             
             try:
-                with patch('skylos.analyzer.Visitor') as mock_visitor_class:
+                with patch('skylos.analyzer.Visitor') as mock_visitor_class, \
+                     patch('skylos.analyzer.TestAwareVisitor') as mock_test_visitor_class, \
+                     patch('skylos.analyzer.FrameworkAwareVisitor') as mock_framework_visitor_class:
+                    
                     mock_visitor = Mock()
                     mock_visitor.defs = []
                     mock_visitor.refs = []
@@ -499,7 +445,13 @@ class TestClass:
                     mock_visitor.exports = set()
                     mock_visitor_class.return_value = mock_visitor
                     
-                    defs, refs, dyn, exports = proc_file(f.name, "test_module")
+                    mock_test_visitor = Mock(spec=TestAwareVisitor)
+                    mock_test_visitor_class.return_value = mock_test_visitor
+                    
+                    mock_framework_visitor = Mock(spec=FrameworkAwareVisitor)
+                    mock_framework_visitor_class.return_value = mock_framework_visitor
+                    
+                    defs, refs, dyn, exports, test_flags, framework_flags = proc_file(f.name, "test_module")
                     
                     mock_visitor_class.assert_called_once_with("test_module", f.name)
                     mock_visitor.visit.assert_called_once()
@@ -507,7 +459,10 @@ class TestClass:
                     assert defs == []
                     assert refs == []
                     assert dyn == set()
+                    ## added new test here for the new methods
                     assert exports == set()
+                    assert test_flags == mock_test_visitor
+                    assert framework_flags == mock_framework_visitor
             finally:
                 Path(f.name).unlink()
     
@@ -517,12 +472,14 @@ class TestClass:
             f.flush()
             
             try:
-                defs, refs, dyn, exports = proc_file(f.name, "test_module")
+                defs, refs, dyn, exports, test_flags, framework_flags = proc_file(f.name, "test_module")
                 
                 assert defs == []
                 assert refs == []
                 assert dyn == set()
                 assert exports == set()
+                assert isinstance(test_flags, TestAwareVisitor)
+                assert isinstance(framework_flags, FrameworkAwareVisitor)
             finally:
                 Path(f.name).unlink()
     
@@ -532,7 +489,10 @@ class TestClass:
             f.flush()
             
             try:
-                with patch('skylos.analyzer.Visitor') as mock_visitor_class:
+                with patch('skylos.analyzer.Visitor') as mock_visitor_class, \
+                     patch('skylos.analyzer.TestAwareVisitor') as mock_test_visitor_class, \
+                     patch('skylos.analyzer.FrameworkAwareVisitor') as mock_framework_visitor_class:
+                    
                     mock_visitor = Mock()
                     mock_visitor.defs = []
                     mock_visitor.refs = []
@@ -540,45 +500,113 @@ class TestClass:
                     mock_visitor.exports = set()
                     mock_visitor_class.return_value = mock_visitor
                     
-                    defs, refs, dyn, exports = proc_file((f.name, "test_module"))
+                    mock_test_visitor = Mock(spec=TestAwareVisitor)
+                    mock_test_visitor_class.return_value = mock_test_visitor
+                    
+                    mock_framework_visitor = Mock(spec=FrameworkAwareVisitor)
+                    mock_framework_visitor_class.return_value = mock_framework_visitor
+                    
+                    # defs, refs, dyn, exports, test_flags, framework_flags = proc_file((f.name, "test_module"))
                     
                     mock_visitor_class.assert_called_once_with("test_module", f.name)
             finally:
                 Path(f.name).unlink()
 
-
-class TestConstants:
+class TestApplyPenalties:
     
-    def test_auto_called_contains_expected_methods(self):
-        """ AUTO_CALLED contains expected magic methods."""
-        assert "__init__" in AUTO_CALLED
-        assert "__enter__" in AUTO_CALLED
-        assert "__exit__" in AUTO_CALLED
+    @patch('skylos.analyzer.detect_framework_usage')
+    def test_private_name_penalty(self, mock_detect_framework, mock_definition, mock_test_aware_visitor, mock_framework_aware_visitor):
+        """private names get penalized."""
+        mock_detect_framework.return_value = None  # or whatever confidence value here that can change later on
+        
+        skylos = Skylos()
+        mock_def = mock_definition(
+            name="_private_func",
+            simple_name="_private_func", 
+            type="function",
+            confidence=100
+        )
+        
+        skylos._apply_penalties(mock_def, mock_test_aware_visitor, mock_framework_aware_visitor)
+        assert mock_def.confidence < 100
+
+    @patch('skylos.analyzer.detect_framework_usage')
+    def test_magic_methods_confidence_zero(self, mock_detect_framework, mock_definition, mock_test_aware_visitor, mock_framework_aware_visitor):
+        """magic methods get confidence of 0."""
+        mock_detect_framework.return_value = None
+        skylos = Skylos()
+        mock_def = mock_definition(
+            name="MyClass.__str__",
+            simple_name="__str__",
+            type="method",
+            confidence=100
+        )
+        
+        skylos._apply_penalties(mock_def, mock_test_aware_visitor, mock_framework_aware_visitor)
+        assert mock_def.confidence == 0
     
-    def test_magic_methods_contains_common_methods(self):
-        """ MAGIC_METHODS contains common magic methods."""
-        assert "__str__" in MAGIC_METHODS
-        assert "__repr__" in MAGIC_METHODS
-        assert "__eq__" in MAGIC_METHODS
-        assert "__len__" in MAGIC_METHODS
+    @patch('skylos.analyzer.detect_framework_usage') 
+    def test_self_cls_parameters_confidence_zero(self, mock_detect_framework, mock_definition, mock_test_aware_visitor, mock_framework_aware_visitor):
+        mock_detect_framework.return_value = None
+        skylos = Skylos()
+        
+        mock_self = mock_definition(
+            name="MyClass.method.self",
+            simple_name="self",
+            type="parameter",
+            confidence=100
+        )
+        
+        mock_cls = mock_definition(
+            name="MyClass.classmethod.cls",
+            simple_name="cls", 
+            type="parameter",
+            confidence=100
+        )
+        
+        skylos._apply_penalties(mock_self, mock_test_aware_visitor, mock_framework_aware_visitor)
+        skylos._apply_penalties(mock_cls, mock_test_aware_visitor, mock_framework_aware_visitor)
+        
+        assert mock_self.confidence == 0
+        assert mock_cls.confidence == 0
     
-    def test_test_method_pattern_matches_correctly(self):
-        """ TEST_METHOD_PATTERN matches test methods correctly."""
-        assert TEST_METHOD_PATTERN.match("test_something")
-        assert TEST_METHOD_PATTERN.match("test_another_thing")
-        assert TEST_METHOD_PATTERN.match("test_123")
-        assert not TEST_METHOD_PATTERN.match("not_a_test")
-        assert not TEST_METHOD_PATTERN.match("test")  # no underscore
-        assert not TEST_METHOD_PATTERN.match("testing_something")  # doesnt start with test_
+    @patch('skylos.analyzer.detect_framework_usage')
+    def test_test_methods_confidence_zero(self, mock_detect_framework, mock_definition, mock_framework_aware_visitor):
+        """test methods get confidence of 0"""
+        mock_detect_framework.return_value = None
+
+        skylos = Skylos()
+        
+        test_visitor = Mock(spec=TestAwareVisitor)
+        test_visitor.is_test_file = True
+        test_visitor.test_decorated_lines = set()
+        
+        mock_def = mock_definition(
+            name="TestMyClass.test_something",
+            simple_name="test_something",
+            type="method",
+            confidence=100
+        )
+        
+        skylos._apply_penalties(mock_def, test_visitor, mock_framework_aware_visitor)
+        assert mock_def.confidence == 0
     
-    def test_default_exclude_folders_contains_expected(self):
-        """ DEFAULT_EXCLUDE_FOLDERS contains expected directories."""
-        expected_folders = {
-            "__pycache__", ".git", ".pytest_cache", ".mypy_cache",
-            ".tox", "htmlcov", ".coverage", "build", "dist",
-            "*.egg-info", "venv", ".venv"
-        }
-        assert expected_folders.issubset(DEFAULT_EXCLUDE_FOLDERS)
+    @patch('skylos.analyzer.detect_framework_usage')
+    def test_underscore_variable_confidence_zero(self, mock_detect_framework, mock_definition, mock_test_aware_visitor, mock_framework_aware_visitor):
+        """underscore variables get confidence of 0."""
+        mock_detect_framework.return_value = None
+
+        skylos = Skylos()
+        
+        mock_def = mock_definition(
+            name="_",
+            simple_name="_",
+            type="variable",
+            confidence=100
+        )
+        
+        skylos._apply_penalties(mock_def, mock_test_aware_visitor, mock_framework_aware_visitor)
+        assert mock_def.confidence == 0
 
 if __name__ == "__main__":
     pytest.main([__file__, "-v"])