skylos 2.1.1__tar.gz → 2.1.2__tar.gz

{skylos-2.1.1 → skylos-2.1.2}/PKG-INFO

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

{skylos-2.1.1 → skylos-2.1.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "skylos"
-version = "2.1.1"
+version = "2.1.2"
 requires-python = ">=3.9"
 description = "A static analysis tool for Python codebases"
 authors = [{name = "oha", email = "aaronoh2015@gmail.com"}]

{skylos-2.1.1 → skylos-2.1.2}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name="skylos",
-    version="2.1.1",
+    version="2.1.2",
     packages=find_packages(),
     python_requires=">=3.9",
     install_requires=[

{skylos-2.1.1 → skylos-2.1.2}/skylos/__init__.py

@@ -1,6 +1,6 @@
 from skylos.analyzer import analyze
 
-__version__ = "2.1.1"
+__version__ = "2.1.2"
 
 def debug_test():
     return "debug-ok"

{skylos-2.1.1 → skylos-2.1.2}/skylos/analyzer.py

@@ -155,18 +155,40 @@ class Skylos:
     
     def _apply_penalties(self, def_obj, visitor, framework):
         confidence=100
+
+        if getattr(visitor, "ignore_lines", None) and def_obj.line in visitor.ignore_lines:
+            def_obj.confidence = 0
+            return
+
+        if def_obj.type == "variable" and def_obj.simple_name == "_":
+            def_obj.confidence = 0
+            return
+
         if def_obj.simple_name.startswith("_") and not def_obj.simple_name.startswith("__"):
             confidence -= PENALTIES["private_name"] 
+
         if def_obj.simple_name.startswith("__") and def_obj.simple_name.endswith("__"):
             confidence -= PENALTIES["dunder_or_magic"]
-        if def_obj.type == "variable" and def_obj.simple_name.isupper():
-            confidence = 0
+
         if def_obj.in_init and def_obj.type in ("function", "class"):
             confidence -= PENALTIES["in_init_file"]
+            
         if def_obj.name.split(".")[0] in self.dynamic:
             confidence -= PENALTIES["dynamic_module"]
+
         if visitor.is_test_file or def_obj.line in visitor.test_decorated_lines:
             confidence -= PENALTIES["test_related"]
+
+        if def_obj.type == "variable" and getattr(framework, "dataclass_fields", None):
+            if def_obj.name in framework.dataclass_fields:
+                def_obj.confidence = 0
+                return
+            
+        if def_obj.type == "variable":
+            fr = getattr(framework, "first_read_lineno", {}).get(def_obj.name)
+            if fr is not None and fr >= def_obj.line:
+                def_obj.confidence = 0
+                return
         
         framework_confidence = detect_framework_usage(def_obj, visitor=framework)
         if framework_confidence is not None:
@@ -262,7 +284,7 @@ class Skylos:
         for d in sorted(self.defs.values(), key=def_sort_key):
             if shown >= 50:
                 break
-            print(f" {d.type:<8} refs={d.references:<2} conf={d.confidence:<3} exported={d.is_exported} line={d.line:<4} {d.name}")
+            print(f" type={d.type} refs={d.references} conf={d.confidence} exported={d.is_exported} line={d.line} name={d.name}")
             shown += 1
 
         unused = []
@@ -304,10 +326,13 @@ def proc_file(file_or_args, mod=None):
 
     try:
         source = Path(file).read_text(encoding="utf-8")
-        tree   = ast.parse(source)
+        ignore_lines = {i for i, line in enumerate(source.splitlines(), start=1)
+                        if "pragma: no skylos" in line}
+        tree = ast.parse(source)
 
         tv = TestAwareVisitor(filename=file)
         tv.visit(tree)
+        tv.ignore_lines = ignore_lines
 
         fv = FrameworkAwareVisitor(filename=file)
         fv.visit(tree)
@@ -315,12 +340,17 @@ def proc_file(file_or_args, mod=None):
         v  = Visitor(mod, file)
         v.visit(tree)
 
+        fv.dataclass_fields = getattr(v, "dataclass_fields", set())
+        fv.first_read_lineno = getattr(v, "first_read_lineno", {})
+
         return v.defs, v.refs, v.dyn, v.exports, tv, fv
+    
     except Exception as e:
         logger.error(f"{file}: {e}")
         if os.getenv("SKYLOS_DEBUG"):
             logger.error(traceback.format_exc())
         dummy_visitor = TestAwareVisitor(filename=file)
+        dummy_visitor.ignore_lines = set()
         dummy_framework_visitor = FrameworkAwareVisitor(filename=file)
 
         return [], [], set(), set(), dummy_visitor, dummy_framework_visitor

{skylos-2.1.1 → skylos-2.1.2}/skylos/cli.py

@@ -10,6 +10,7 @@ from skylos.codemods import (
     remove_unused_function_cst,
 )
 import pathlib
+import skylos
 
 try:
     import inquirer
@@ -144,7 +145,7 @@ def print_badge(dead_code_count: int, logger):
         logger.info(f"![Dead Code: {dead_code_count}](https://img.shields.io/badge/Dead_Code-{dead_code_count}_detected-orange?logo=codacy&logoColor=red)")
         logger.info("```")
 
-def main() -> None:
+def main():
     if len(sys.argv) > 1 and sys.argv[1] == 'run':
         try:
             start_server()
@@ -158,6 +159,14 @@ def main() -> None:
         description="Detect unreachable functions and unused imports in a Python project"
     )
     parser.add_argument("path", help="Path to the Python project")
+
+    parser.add_argument(
+        "--version",
+        action="version", 
+        version=f"skylos {skylos.__version__}",
+        help="Show version and exit"
+    )
+    
     parser.add_argument(
         "--json",
         action="store_true",
@@ -368,6 +377,8 @@ def main() -> None:
             for i, item in enumerate(unused_variables, 1):
                 logger.info(f"{Colors.GRAY}{i:2d}. {Colors.RESET}{Colors.YELLOW}{item['name']}{Colors.RESET}")
                 logger.info(f"    {Colors.GRAY}└─ {item['file']}:{item['line']}{Colors.RESET}")
+        else:
+            logger.info(f"\n{Colors.GREEN}✓ All variables are being used!{Colors.RESET}")
                 
         if unused_classes:
             logger.info(f"\n{Colors.YELLOW}{Colors.BOLD} - Unused Classes{Colors.RESET}")
@@ -375,9 +386,8 @@ def main() -> None:
             for i, item in enumerate(unused_classes, 1):
                 logger.info(f"{Colors.GRAY}{i:2d}. {Colors.RESET}{Colors.YELLOW}{item['name']}{Colors.RESET}")
                 logger.info(f"    {Colors.GRAY}└─ {item['file']}:{item['line']}{Colors.RESET}")
-
         else:
-            logger.info(f"\n{Colors.GREEN}✓ All variables are being used!{Colors.RESET}")
+            logger.info(f"\n{Colors.GREEN}✓ All classes are being used!{Colors.RESET}")
 
         dead_code_count = len(unused_functions) + len(unused_imports) + len(unused_variables) + len(unused_classes) + len(unused_parameters)
 

{skylos-2.1.1 → skylos-2.1.2}/skylos/constants.py

@@ -1,5 +1,4 @@
 import re
-from pathlib import Path
 
 PENALTIES = {
     "private_name": 80,   
@@ -35,10 +34,10 @@ DEFAULT_EXCLUDE_FOLDERS = {
     "htmlcov", ".coverage", "build", "dist", "*.egg-info", "venv", ".venv"
 }
 
-def is_test_path(p: Path | str) -> bool:
+def is_test_path(p):
     return bool(TEST_FILE_RE.search(str(p)))
 
-def is_framework_path(p: Path | str) -> bool:
+def is_framework_path(p):
     return bool(FRAMEWORK_FILE_RE.search(str(p)))
 
 def parse_exclude_folders(user_exclude_folders= None, use_defaults= True, include_folders= None):

{skylos-2.1.1 → skylos-2.1.2}/skylos/visitor.py

@@ -3,13 +3,15 @@ import ast
 from pathlib import Path
 import re
 
-PYTHON_BUILTINS={"print", "len", "str", "int", "float", "list", "dict", "set", "tuple", "range", "open", 
+PYTHON_BUILTINS={"print", "len", "str", "int", "float", "list", "dict", "set", "tuple", "range", "open", "reversed", 
                  "super", "object", "type", "enumerate", "zip", "map", "filter", "sorted", "sum", "min", 
                 "next", "iter", "bytes", "bytearray", "format", "round", "abs", "complex", "hash", "id", "bool", "callable", 
                 "getattr", "max", "all", "any", "setattr", "hasattr", "isinstance", "globals", "locals", 
                 "vars", "dir" ,"property", "classmethod", "staticmethod"}
 DYNAMIC_PATTERNS={"getattr", "globals", "eval", "exec"}
 
+## "🥚" hi :) 
+
 class Definition:
     
     def __init__(self, name, t, filename, line):
@@ -60,9 +62,17 @@ class Visitor(ast.NodeVisitor):
         self.local_var_maps = []
         self.in_cst_class = 0
         self.local_type_maps = []
+        self._dataclass_stack = [] 
+        self.dataclass_fields = set()
+        self.first_read_lineno = {} 
 
     def add_def(self, name, t, line):
-        if name not in {d.name for d in self.defs}:
+        found = False
+        for d in self.defs:
+            if d.name == name:
+                found = True
+                break
+        if not found:
             self.defs.append(Definition(name, t, self.file, line))
 
     def add_ref(self, name):
@@ -72,8 +82,23 @@ class Visitor(ast.NodeVisitor):
         if name in self.alias:
             return self.alias[name]
         if name in PYTHON_BUILTINS:
+            if self.mod:
+                mod_candidate = f"{self.mod}.{name}"
+            else:
+                mod_candidate = name
+            if any(d.name == mod_candidate for d in self.defs):
+                return mod_candidate
+            
+        if self.mod:
+            return f"{self.mod}.{name}"
+        else:
             return name
-        return f"{self.mod}.{name}" if self.mod else name
+    
+    def visit_Global(self, node):
+        if self.current_function_scope and self.local_var_maps:
+            for name in node.names:
+                self.local_var_maps[-1][name] = f"{self.mod}.{name}"
+        return
 
     def visit_annotation(self, node):
         if node is not None:
@@ -148,7 +173,11 @@ class Visitor(ast.NodeVisitor):
         
         qualified_name= ".".join(filter(None, name_parts))
 
-        self.add_def(qualified_name,"method"if self.cls else"function",node.lineno)
+        if self.cls:
+            def_type = "method"
+        else:
+            def_type = "function"
+        self.add_def(qualified_name, def_type, node.lineno)
         
         self.current_function_scope.append(node.name)
         self.local_var_maps.append({})
@@ -183,19 +212,41 @@ class Visitor(ast.NodeVisitor):
         self.add_def(cname, "class",node.lineno)
         
         is_cst = False
-        
+        is_dc  = False
+
         for base in node.bases:
             base_name = ""
+
             if isinstance(base, ast.Attribute):
                 base_name = base.attr
+                
             elif isinstance(base, ast.Name):
                 base_name = base.id
             self.visit(base)
+
             if base_name in {"CSTTransformer", "CSTVisitor"}:
                 is_cst = True
+                
         for keyword in node.keywords:
             self.visit(keyword.value)
+
         for decorator in node.decorator_list:
+            def _is_dc(dec):
+                if isinstance(dec, ast.Call):
+                    target = dec.func
+                else:
+                    target = dec
+
+                if isinstance(target, ast.Name):
+                    return target.id == "dataclass"
+                
+                if isinstance(target, ast.Attribute):
+                    return target.attr == "dataclass"
+                
+                return False
+            
+            if _is_dc(decorator):
+                is_dc = True
             self.visit(decorator)
         
         prev= self.cls
@@ -203,10 +254,13 @@ class Visitor(ast.NodeVisitor):
             self.in_cst_class += 1
 
         self.cls= node.name
+        self._dataclass_stack.append(is_dc)
         for b in node.body:
             self.visit(b)
 
         self.cls= prev
+        self._dataclass_stack.pop()
+    
         if is_cst:
             self.in_cst_class -= 1
 
@@ -220,6 +274,7 @@ class Visitor(ast.NodeVisitor):
                 name_simple = t.id
                 scope_parts = [self.mod]
                 if self.cls: scope_parts.append(self.cls)
+
                 if self.current_function_scope: scope_parts.extend(self.current_function_scope)
                 prefix = '.'.join(filter(None, scope_parts))
                 if prefix:
@@ -228,9 +283,16 @@ class Visitor(ast.NodeVisitor):
                     var_name = name_simple
 
                 self.add_def(var_name, "variable", t.lineno)
+                if (self._dataclass_stack and self._dataclass_stack[-1] 
+                    and self.cls 
+                    and not self.current_function_scope):
+                    self.dataclass_fields.add(var_name)
+
                 if self.current_function_scope and self.local_var_maps:
                     self.local_var_maps[-1][name_simple] = var_name
+
             elif isinstance(t, (ast.Tuple, ast.List)):
+
                 for elt in t.elts:
                     _define(elt)
         _define(node.target)
@@ -243,19 +305,24 @@ class Visitor(ast.NodeVisitor):
                 self.local_var_maps and 
                 nm in self.local_var_maps[-1]):
 
-                self.add_ref(self.local_var_maps[-1][nm])
+                # self.add_ref(self.local_var_maps[-1][nm])
+                fq = self.local_var_maps[-1][nm]
+                self.add_ref(fq)
+                var_name = fq
 
             else:
                 self.add_ref(self.qual(nm))
-            scope_parts = [self.mod]
-            if self.cls: scope_parts.append(self.cls)
+                scope_parts = [self.mod]
+                if self.cls: 
+                    scope_parts.append(self.cls)
 
-            if self.current_function_scope: scope_parts.extend(self.current_function_scope)
-            prefix = '.'.join(filter(None, scope_parts))
-            if prefix:
-                var_name = f"{prefix}.{nm}"
-            else:
-                var_name = nm
+                if self.current_function_scope: 
+                    scope_parts.extend(self.current_function_scope)
+                prefix = '.'.join(filter(None, scope_parts))
+                if prefix:
+                    var_name = f"{prefix}.{nm}"
+                else:
+                    var_name = nm
 
             self.add_def(var_name, "variable", node.lineno)
             if self.current_function_scope and self.local_var_maps:
@@ -292,14 +359,19 @@ class Visitor(ast.NodeVisitor):
                 if self.current_function_scope:
                     scope_parts.extend(self.current_function_scope)
 
-                prefix = '.'.join(filter(None, scope_parts))
-                if prefix:
-                    var_name = f"{prefix}.{name_simple}"
+                if (self.current_function_scope and self.local_var_maps 
+                        and name_simple in self.local_var_maps[-1]):
+                    var_name = self.local_var_maps[-1][name_simple]
                 else:
-                    var_name = name_simple
+                    prefix = '.'.join(filter(None, scope_parts))
+                    if prefix:
+                        var_name = f"{prefix}.{name_simple}"
+                    else:
+                        var_name = name_simple
 
                 self.add_def(var_name, "variable", target_node.lineno)
-                if self.current_function_scope and self.local_var_maps:
+                if (self.current_function_scope and self.local_var_maps 
+                        and name_simple not in self.local_var_maps[-1]):
                     self.local_var_maps[-1][name_simple] = var_name
 
             elif isinstance(target_node, (ast.Tuple, ast.List)):
@@ -403,18 +475,19 @@ class Visitor(ast.NodeVisitor):
         if isinstance(node.ctx, ast.Load):
             for param_name, param_full_name in self.current_function_params:
                 if node.id == param_name:
+                    self.first_read_lineno.setdefault(param_full_name, node.lineno)
                     self.add_ref(param_full_name)
                     return
             
-            if (self.current_function_scope and 
-                self.local_var_maps 
-                and self.local_var_maps 
+            if (self.current_function_scope and self.local_var_maps
                 and node.id in self.local_var_maps[-1]):
-
-                self.add_ref(self.local_var_maps[-1][node.id])
+                fq = self.local_var_maps[-1][node.id]
+                self.first_read_lineno.setdefault(fq, node.lineno)
+                self.add_ref(fq)
                 return
             
             qualified = self.qual(node.id)
+            self.first_read_lineno.setdefault(qualified, node.lineno)
             self.add_ref(qualified)
             if node.id in DYNAMIC_PATTERNS:
                 self.dyn.add(self.mod.split(".")[0])

{skylos-2.1.1 → skylos-2.1.2}/skylos.egg-info/PKG-INFO

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

{skylos-2.1.1 → skylos-2.1.2}/skylos.egg-info/SOURCES.txt

@@ -27,6 +27,7 @@ test/test_codemods.py
 test/test_constants.py
 test/test_framework_aware.py
 test/test_integration.py
+test/test_new_behaviours.py
 test/test_skylos.py
 test/test_test_aware.py
 test/test_visitor.py

{skylos-2.1.1 → skylos-2.1.2}/test/test_analyzer.py

@@ -8,11 +8,9 @@ from skylos.test_aware import TestAwareVisitor
 from skylos.framework_aware import FrameworkAwareVisitor
 
 from skylos.analyzer import (
-    Skylos, 
-    parse_exclude_folders, 
+    Skylos,  
     proc_file, 
-    analyze,
-    DEFAULT_EXCLUDE_FOLDERS,
+    analyze
 )
 
 @pytest.fixture
@@ -97,40 +95,6 @@ def internal_function():
         
         yield temp_path
 
-class TestParseExcludeFolders:
-    
-    def test_default_exclude_folders_included(self):
-        """default folders are included by default."""
-        result = parse_exclude_folders(None, use_defaults=True)
-        assert DEFAULT_EXCLUDE_FOLDERS.issubset(result)
-    
-    def test_default_exclude_folders_disabled(self):
-        """default folders can be disabled."""
-        result = parse_exclude_folders(None, use_defaults=False)
-        assert not DEFAULT_EXCLUDE_FOLDERS.intersection(result)
-    
-    def test_user_exclude_folders_added(self):
-        """user-specified folders are added."""
-        user_folders = {"custom_folder", "another_folder"}
-        result = parse_exclude_folders(user_folders, use_defaults=True)
-        assert user_folders.issubset(result)
-        assert DEFAULT_EXCLUDE_FOLDERS.issubset(result)
-    
-    def test_include_folders_override_defaults(self):
-        """include_folders can override defaults."""
-        include_folders = {"__pycache__", ".git"}
-        result = parse_exclude_folders(None, use_defaults=True, include_folders=include_folders)
-        for folder in include_folders:
-            assert folder not in result
-    
-    def test_include_folders_override_user_excludes(self):
-        """include_folders can override user excludes."""
-        user_excludes = {"custom_folder", "another_folder"}
-        include_folders = {"custom_folder"}
-        result = parse_exclude_folders(user_excludes, use_defaults=False, include_folders=include_folders)
-        assert "custom_folder" not in result
-        assert "another_folder" in result
-
 class TestSkylos:
     
     @pytest.fixture
@@ -144,7 +108,6 @@ class TestSkylos:
         assert isinstance(skylos.exports, defaultdict)
     
     def test_module_name_generation(self, skylos):
-        """Test module name generation from file paths."""
         root = Path("/project")
         
         # test a regular Python file
@@ -315,7 +278,7 @@ class TestHeuristics:
     
     def test_auto_called_methods_get_references(self, skylos_with_class_methods):
         """auto-called methods get reference counts when class is used."""
-        skylos, mock_class, mock_init, mock_enter = skylos_with_class_methods
+        skylos, _, mock_init, mock_enter = skylos_with_class_methods
         
         skylos._apply_heuristics()
         
@@ -451,7 +414,7 @@ class TestClass:
                     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")
+                    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()
@@ -472,7 +435,7 @@ class TestClass:
             f.flush()
             
             try:
-                defs, refs, dyn, exports, test_flags, framework_flags, _ = proc_file(f.name, "test_module")
+                defs, refs, dyn, exports, test_flags, framework_flags = proc_file(f.name, "test_module")
                 
                 assert defs == []
                 assert refs == []
@@ -506,7 +469,7 @@ class TestClass:
                     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"))
+                    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:

skylos-2.1.2/test/test_new_behaviours.py

@@ -0,0 +1,52 @@
+import json
+from skylos.analyzer import analyze
+
+def test_dataclass_fields(tmp_path):
+    p = tmp_path / "dc.py"
+    p.write_text(
+        "from dataclasses import dataclass\n"
+        "@dataclass\n"
+        "class C:\n"
+        "    x: int = 1\n"
+        "    y: int = 2\n"
+        "def f(c: C):\n"
+        "    return c.x + c.y\n"
+        "f(C())\n"
+    )
+    result = json.loads(analyze(str(tmp_path), conf=0))
+    assert result['unused_variables'] == []
+
+def test_dead_store_guard(tmp_path):
+    p = tmp_path / "dstore.py"
+    p.write_text(
+        "lst=[1,2,3]\n"
+        "dir=0\n"
+        "if 'a' in lst:\n"
+        "    pass\n"
+        "else:\n"
+        "    dir=1\n"
+        "print(dir)\n"
+    )
+    result = json.loads(analyze(str(tmp_path), conf=0))
+    assert result['unused_variables'] == []
+
+def test_unused_constant_reported(tmp_path):
+    p = tmp_path / "pool.py"
+    p.write_text(
+        "from concurrent.futures import ProcessPoolExecutor\n"
+        "PROCESS_POOL=None\n"
+        "NEVER_USED=123\n"
+        "def get_pool():\n"
+        "    global PROCESS_POOL\n"
+        "    if PROCESS_POOL is None:\n"
+        "        PROCESS_POOL=ProcessPoolExecutor(max_workers=2)\n"
+        "    return PROCESS_POOL\n"
+        "get_pool()\n"
+    )
+    result = json.loads(analyze(str(tmp_path), conf=0))
+    names = set()
+    for v in result['unused_variables']:
+        names.add(v['name'])
+
+    assert 'NEVER_USED' in names
+    assert 'PROCESS_POOL' not in names