skylos 2.0.0__py3-none-any.whl → 2.1.1__py3-none-any.whl

skylos/visitor.py

@@ -1,11 +1,7 @@
 #!/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")
-
+import re
 
 PYTHON_BUILTINS={"print", "len", "str", "int", "float", "list", "dict", "set", "tuple", "range", "open", 
                  "super", "object", "type", "enumerate", "zip", "map", "filter", "sorted", "sum", "min", 
@@ -61,6 +57,9 @@ class Visitor(ast.NodeVisitor):
         self.exports= set()
         self.current_function_scope= []
         self.current_function_params= []
+        self.local_var_maps = []
+        self.in_cst_class = 0
+        self.local_type_maps = []
 
     def add_def(self, name, t, line):
         if name not in {d.name for d in self.defs}:
@@ -89,17 +88,10 @@ class Visitor(ast.NodeVisitor):
         if not isinstance(annotation_str, str):
             return
 
-        if DBG:
-            log.debug(f"parsing annotation: {annotation_str}")
-
-
         try:
             parsed = ast.parse(annotation_str, mode="eval")
             self.visit(parsed.body)
         except:
-            if DBG:
-                if DBG: log.debug("annotation parse failed")
-            
             for tok in re.findall(r"[A-Za-z_][A-Za-z0-9_]*", annotation_str):
                 self.add_ref(tok)
 
@@ -159,7 +151,9 @@ class Visitor(ast.NodeVisitor):
         self.add_def(qualified_name,"method"if self.cls else"function",node.lineno)
         
         self.current_function_scope.append(node.name)
-        
+        self.local_var_maps.append({})
+        self.local_type_maps.append({})
+
         old_params = self.current_function_params
         self.current_function_params = []
         
@@ -179,6 +173,8 @@ class Visitor(ast.NodeVisitor):
             
         self.current_function_scope.pop()
         self.current_function_params = old_params
+        self.local_var_maps.pop()
+        self.local_type_maps.pop()
         
     visit_AsyncFunctionDef= visit_FunctionDef
 
@@ -186,29 +182,86 @@ class Visitor(ast.NodeVisitor):
         cname =f"{self.mod}.{node.name}"
         self.add_def(cname, "class",node.lineno)
         
+        is_cst = 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:
             self.visit(decorator)
         
         prev= self.cls
+        if is_cst:
+            self.in_cst_class += 1
 
         self.cls= node.name
         for b in node.body:
             self.visit(b)
 
         self.cls= prev
+        if is_cst:
+            self.in_cst_class -= 1
 
     def visit_AnnAssign(self, node):
         self.visit_annotation(node.annotation)
         if node.value:
             self.visit(node.value)
-        self.visit(node.target)
+    
+        def _define(t):
+            if isinstance(t, ast.Name):
+                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:
+                    var_name = f"{prefix}.{name_simple}"
+                else:
+                    var_name = name_simple
+
+                self.add_def(var_name, "variable", t.lineno)
+                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)
 
     def visit_AugAssign(self, node):
-        self.visit(node.target)
+        if isinstance(node.target, ast.Name):
+            nm = node.target.id
+            if (self.current_function_scope and 
+                self.local_var_maps and 
+                self.local_var_maps and 
+                nm in self.local_var_maps[-1]):
+
+                self.add_ref(self.local_var_maps[-1][nm])
+
+            else:
+                self.add_ref(self.qual(nm))
+            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
+
+            self.add_def(var_name, "variable", node.lineno)
+            if self.current_function_scope and self.local_var_maps:
+                self.local_var_maps[-1][nm] = var_name
+        else:
+            self.visit(node.target)
         self.visit(node.value)
 
     def visit_Subscript(self, node):
@@ -227,21 +280,27 @@ class Visitor(ast.NodeVisitor):
         def process_target_for_def(target_node):
             if isinstance(target_node, ast.Name):
                 name_simple = target_node.id
+                if (name_simple == "METADATA_DEPENDENCIES"
+                    and self.cls and self.in_cst_class > 0):
+                    return
                 if name_simple == "__all__" and not self.current_function_scope and not self.cls:
                     return
 
                 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))
-                var_name = f"{prefix}.{name_simple}" if prefix else name_simple
+                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:
+                    self.local_var_maps[-1][name_simple] = var_name
 
             elif isinstance(target_node, (ast.Tuple, ast.List)):
                 for elt in target_node.elts:
@@ -249,7 +308,7 @@ class Visitor(ast.NodeVisitor):
 
         for t in node.targets:
             process_target_for_def(t)
-        
+
         for target in node.targets:
             if isinstance(target, ast.Name) and target.id == "__all__":
                 if isinstance(node.value, (ast.List, ast.Tuple)):
@@ -259,12 +318,48 @@ class Visitor(ast.NodeVisitor):
                             value = elt.value
                         elif hasattr(elt, 's') and isinstance(elt.s, str):
                             value = elt.s
-                            
+
                         if value is not None:
-                            export_name = f"{self.mod}.{value}" if self.mod else value
+                            if self.mod:
+                                export_name = f"{self.mod}.{value}"
+                            else:
+                                export_name = value
+
                             self.add_ref(export_name)
-                            self.add_ref(value) 
-        
+                            self.add_ref(value)
+
+        try:
+            if isinstance(node.value, ast.Call):
+                callee = node.value.func
+                fqname = None
+
+                if isinstance(callee, ast.Name):
+                    fqname = self.alias.get(callee.id, self.qual(callee.id))
+
+                elif isinstance(callee, ast.Attribute):
+                    parts = []
+                    cur = callee
+                    while isinstance(cur, ast.Attribute):
+                        parts.append(cur.attr)
+                        cur = cur.value
+                    head = None
+                    if isinstance(cur, ast.Name):
+                        head = self.alias.get(cur.id, self.qual(cur.id))
+                    if head:
+                        fqname = ".".join([head] + list(reversed(parts)))
+
+                if fqname and self.current_function_scope and self.local_type_maps:
+                    def _mark_target(t):
+                        if isinstance(t, ast.Name):
+                            self.local_type_maps[-1][t.id] = fqname
+                        elif isinstance(t, (ast.Tuple, ast.List)):
+                            for elt in t.elts:
+                                _mark_target(elt)
+                    for t in node.targets:
+                        _mark_target(t)
+        except Exception:
+            pass
+
         self.generic_visit(node)
 
     def visit_Call(self, node):
@@ -284,7 +379,10 @@ class Visitor(ast.NodeVisitor):
             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 "")
+                    if self.mod:
+                        self.dyn.add(self.mod.split(".")[0])
+                    else:
+                        self.dyn.add("")
         
         elif isinstance(node.func, ast.Name) and node.func.id == "globals":
             parent = getattr(node, 'parent', None)
@@ -296,33 +394,80 @@ class Visitor(ast.NodeVisitor):
                 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 "")
+            root_mod = ""
+            if self.mod:
+                root_mod = self.mod.split(".")[0]
+            self.dyn.add(root_mod)
 
     def visit_Name(self, node):
         if isinstance(node.ctx, ast.Load):
             for param_name, param_full_name in self.current_function_params:
                 if node.id == param_name:
                     self.add_ref(param_full_name)
-                    break
+                    return
+            
+            if (self.current_function_scope and 
+                self.local_var_maps 
+                and self.local_var_maps 
+                and node.id in self.local_var_maps[-1]):
 
-            else:
-                # not parameter, handle normally
-                qualified = self.qual(node.id)
-                self.add_ref(qualified)
-                if node.id in DYNAMIC_PATTERNS:
-                    self.dyn.add(self.mod.split(".")[0])
+                self.add_ref(self.local_var_maps[-1][node.id])
+                return
+            
+            qualified = self.qual(node.id)
+            self.add_ref(qualified)
+            if node.id in DYNAMIC_PATTERNS:
+                self.dyn.add(self.mod.split(".")[0])
 
     def visit_Attribute(self, node):
         self.generic_visit(node)
-        if isinstance(node.ctx, ast.Load) and isinstance(node.value, ast.Name):
-            if node.value.id in [param_name for param_name, _ in self.current_function_params]:
-                # mark parameter as referenced
-                for param_name, param_full_name in self.current_function_params:
-                    if node.value.id == param_name:
-                        self.add_ref(param_full_name)
-                        break
-
-            self.add_ref(f"{self.qual(node.value.id)}.{node.attr}")
+
+        if not isinstance(node.ctx, ast.Load):
+            return
+
+        if isinstance(node.value, ast.Name):
+            base = node.value.id
+
+            param_hit = None
+            for param_name, param_full in self.current_function_params:
+                if base == param_name:
+                    param_hit = (param_name, param_full)
+                    break
+
+            if param_hit:
+                self.add_ref(param_hit[1])
+
+            if self.cls and base in {"self", "cls"}:
+                if self.mod:
+                    owner = f"{self.mod}.{self.cls}"
+                else:
+                    owner = self.cls
+
+                self.add_ref(f"{owner}.{node.attr}")
+                return
+
+            if (self.current_function_scope and 
+                self.local_type_maps and 
+                self.local_type_maps[-1].get(base)):
+                
+                self.add_ref(f"{self.local_type_maps[-1][base]}.{node.attr}")
+                return
+
+            self.add_ref(f"{self.qual(base)}.{node.attr}")
+
+    def visit_NamedExpr(self, node):
+        self.visit(node.value)
+        if isinstance(node.target, ast.Name):
+            nm = node.target.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))
+            var_name = f"{prefix}.{nm}" if prefix else nm
+            self.add_def(var_name, "variable", node.lineno)
+            if self.current_function_scope and self.local_var_maps:
+                self.local_var_maps[-1][nm] = var_name
+            self.add_ref(var_name)
 
     def visit_keyword(self, node):
         self.visit(node.value)

{skylos-2.0.0.dist-info → skylos-2.1.1.dist-info}/METADATA

@@ -1,8 +1,11 @@
 Metadata-Version: 2.4
 Name: skylos
-Version: 2.0.0
+Version: 2.1.1
 Summary: A static analysis tool for Python codebases
 Author-email: oha <aaronoh2015@gmail.com>
 Requires-Python: >=3.9
 Requires-Dist: inquirer>=3.0.0
+Requires-Dist: flask>=2.1.1
+Requires-Dist: flask-cors>=3.0.0
+Requires-Dist: libcst>=1.8.2
 Dynamic: requires-python

{skylos-2.0.0.dist-info → skylos-2.1.1.dist-info}/RECORD

@@ -1,11 +1,12 @@
-skylos/__init__.py,sha256=xIvJTzzvvgfcQWYMckJFXNNlXPpU1gjO1IldPy7T_N4,151
-skylos/analyzer.py,sha256=TDr_szli65cuQWD6BUcQCUFleM1R-QZD0uRUoHlU6As,14145
-skylos/cli.py,sha256=Xqc_vnueic0D39FI0YzMtJObLsn8MqFFCUnY1nrpEt4,18115
+skylos/__init__.py,sha256=vXBgYBrUqN3o2LxNCrT2pUVGS-Dnnkcakw7jItvQjXA,151
+skylos/analyzer.py,sha256=JoQ_otvLmI5k64y3h11jVZEWuA6u3npY15Nwy1vrGi0,14995
+skylos/cli.py,sha256=bRxhvKkw_VWQVHT6WxKyX9i3qJjGuJJaEJ3QI8FIpZw,15887
+skylos/codemods.py,sha256=A5dNwTJiYtgP3Mv8NQ03etdfi9qNHSECv1GRpLyDCYU,3213
 skylos/constants.py,sha256=vAfKls0OuR5idtXzeMDfYv5-wLtYWDe1NW5TSUJT8RI,1636
-skylos/framework_aware.py,sha256=vbZ1CZIL_2TOEkdH8uVSPPihLM2ctqA01zEHL8HG5sw,5768
+skylos/framework_aware.py,sha256=eX4oU0jQwDWejkkW4kjRNctre27sVLHK1CTDDiqPqRw,13054
 skylos/server.py,sha256=5Rlgy3LdE8I5TWRJJh0n19JqhVYaAOc9fUtRjL-PpX8,16270
 skylos/test_aware.py,sha256=kxYoMG2m02kbMlxtFOM-MWJO8qqxHviP9HgAMbKRfvU,2304
-skylos/visitor.py,sha256=FXNck0qjVB3lfp4X63D5-bE1NsvUTbfvT17ivIevhjk,12654
+skylos/visitor.py,sha256=i-YWVenc8mG0dWzYi945HmktIE2RkgL7rBT7VUnhkLI,18073
 test/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 test/compare_tools.py,sha256=0g9PDeJlbst-7hOaQzrL4MiJFQKpqM8q8VeBGzpPczg,22738
 test/conftest.py,sha256=57sTF6vLL5U0CVKwGQFJcRs6n7t1dEHIriQoSluNmAI,6418
@@ -13,8 +14,9 @@ test/diagnostics.py,sha256=ExuFOCVpc9BDwNYapU96vj9RXLqxji32Sv6wVF4nJYU,13802
 test/test_analyzer.py,sha256=vZ-0cSF_otm7ZYdp6U3a8eWGwRZ6Tf0tVuJxYqcxdqM,22816
 test/test_changes_analyzer.py,sha256=l1hspCFz-sF8gqOilJvntUDuGckwhYsVtzvSRB13ZWw,5085
 test/test_cli.py,sha256=rtdKzanDRJT_F92jKkCQFdhvlfwVJxfXKO8Hrbn-mIg,13180
+test/test_codemods.py,sha256=Tbp9jE95HDl77EenTmyTtB1Sc3L8fwY9xiMNVDN5lxo,4522
 test/test_constants.py,sha256=pMuDy0UpC81zENMDCeK6Bqmm3BR_HHZQSlMG-9TgOm0,12602
-test/test_framework_aware.py,sha256=tJ7bnhiGeSdsAvrWaGJO5ovTrw9n9BBk6o1HCw15yDA,11693
+test/test_framework_aware.py,sha256=G9va1dEQ31wsvd4X7ROf_1YhhAQG5CogB7v0hYCojQ8,8802
 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
@@ -26,8 +28,8 @@ test/sample_repo/sample_repo/commands.py,sha256=b6gQ9YDabt2yyfqGbOpLo0osF7wya8O4
 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-2.0.0.dist-info/METADATA,sha256=gVlJTPqEjfbbnn0TGbDT5aEx8TBtD1r-mitvOfJBI-Y,224
-skylos-2.0.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-skylos-2.0.0.dist-info/entry_points.txt,sha256=zzRpN2ByznlQoLeuLolS_TFNYSQxUGBL1EXQsAd6bIA,43
-skylos-2.0.0.dist-info/top_level.txt,sha256=f8GA_7KwfaEopPMP8-EXDQXaqd4IbsOQPakZy01LkdQ,12
-skylos-2.0.0.dist-info/RECORD,,
+skylos-2.1.1.dist-info/METADATA,sha256=Sodf-ShJV4dS2Y0AC611OAO2WmQhZT6aYIz0w0Df6a8,314
+skylos-2.1.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+skylos-2.1.1.dist-info/entry_points.txt,sha256=zzRpN2ByznlQoLeuLolS_TFNYSQxUGBL1EXQsAd6bIA,43
+skylos-2.1.1.dist-info/top_level.txt,sha256=f8GA_7KwfaEopPMP8-EXDQXaqd4IbsOQPakZy01LkdQ,12
+skylos-2.1.1.dist-info/RECORD,,

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