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

skylos/visitor.py

@@ -1,28 +1,27 @@
 #!/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","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"}
+PYTHON_BUILTINS={"print", "len", "str", "int", "float", "list", "dict", "set", "tuple", "range", "open", 
+                 "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"}
 
 class Definition:
-    __slots__ = ('name', 'type', 'filename', 'line', 'simple_name', 'confidence', 'references', 'is_exported', 'in_init')
     
-    def __init__(self, n, t, f, l):
-        self.name = n
+    def __init__(self, name, t, filename, line):
+        self.name = name
         self.type = t
-        self.filename = f
-        self.line = l
-        self.simple_name = n.split('.')[-1]
+        self.filename = filename
+        self.line = line
+        self.simple_name = name.split('.')[-1]
         self.confidence = 100
         self.references = 0
         self.is_exported = False
-        self.in_init = "__init__.py" in str(f)
+        self.in_init = "__init__.py" in str(filename)
     
     def to_dict(self):
         if self.type == "method" and "." in self.name:
@@ -48,26 +47,33 @@ class Definition:
 
 class Visitor(ast.NodeVisitor):
     def __init__(self,mod,file):
-        self.mod=mod
-        self.file=file
-        self.defs=[]
-        self.refs=[]
-        self.cls=None
-        self.alias={}
-        self.dyn=set()
-        self.exports=set()
-        self.current_function_scope = []
-        self.current_function_params = []
-
-    def add_def(self,n,t,l):
-        if n not in{d.name for d in self.defs}:self.defs.append(Definition(n,t,self.file,l))
-
-    def add_ref(self,n):self.refs.append((n,self.file))
-
-    def qual(self,n):
-        if n in self.alias:return self.alias[n]
-        if n in PYTHON_BUILTINS:return n
-        return f"{self.mod}.{n}"if self.mod else n
+        self.mod= mod
+        self.file= file
+        self.defs= []
+        self.refs= []
+        self.cls= None
+        self.alias= {}
+        self.dyn= set()
+        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}:
+            self.defs.append(Definition(name, t, self.file, line))
+
+    def add_ref(self, name):
+        self.refs.append((name, self.file))
+
+    def qual(self, name):
+        if name in self.alias:
+            return self.alias[name]
+        if name in PYTHON_BUILTINS:
+            return name
+        return f"{self.mod}.{name}" if self.mod else name
 
     def visit_annotation(self, node):
         if node is not None:
@@ -82,25 +88,17 @@ class Visitor(ast.NodeVisitor):
         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")
             self.visit(parsed.body)
-        except Exception:
-            if DBG:
-                log.debug("[visitor] inner-annotation parse failed:\n" +
-                        traceback.format_exc())
-            # keep going but dont swallow symbol names:
+        except:
             for tok in re.findall(r"[A-Za-z_][A-Za-z0-9_]*", annotation_str):
                 self.add_ref(tok)
 
-    def visit_Import(self,node):
+    def visit_Import(self, node):
         for a in node.names:
-            full=a.name
-            self.alias[a.asname or a.name.split(".")[-1]]=full
+            full= a.name
+            self.alias[a.asname or a.name.split(".")[-1]]= full
             self.add_def(full,"import",node.lineno)
 
     def visit_ImportFrom(self, node):
@@ -127,6 +125,7 @@ class Visitor(ast.NodeVisitor):
             self.visit_annotation(arg.annotation)
         for arg in args.posonlyargs:
             self.visit_annotation(arg.annotation)
+            
         for arg in args.kwonlyargs:
             self.visit_annotation(arg.annotation)
         if args.vararg:
@@ -143,16 +142,18 @@ class Visitor(ast.NodeVisitor):
         outer_scope_prefix = '.'.join(self.current_function_scope) + '.' if self.current_function_scope else ''
         
         if self.cls:
-            name_parts = [self.mod, self.cls, outer_scope_prefix + node.name]
+            name_parts= [self.mod, self.cls, outer_scope_prefix + node.name]
         else:
-            name_parts = [self.mod, outer_scope_prefix + node.name]
+            name_parts= [self.mod, outer_scope_prefix + node.name]
         
-        qualified_name = ".".join(filter(None, name_parts))
+        qualified_name= ".".join(filter(None, name_parts))
 
         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 = []
         
@@ -172,32 +173,95 @@ 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
+    visit_AsyncFunctionDef= visit_FunctionDef
 
-    def visit_ClassDef(self,node):
-        cname=f"{self.mod}.{node.name}"
-        self.add_def(cname,"class",node.lineno)
+    def visit_ClassDef(self, node):
+        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;self.cls=node.name
-        for b in node.body:self.visit(b)
-        self.cls=prev
+        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):
@@ -215,8 +279,11 @@ class Visitor(ast.NodeVisitor):
     def visit_Assign(self, node):
         def process_target_for_def(target_node):
             if isinstance(target_node, ast.Name):
-                var_name_simple = target_node.id
-                if var_name_simple == "__all__" and not self.current_function_scope and not self.cls:
+                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]
@@ -224,11 +291,16 @@ class Visitor(ast.NodeVisitor):
                     scope_parts.append(self.cls)
                 if self.current_function_scope:
                     scope_parts.extend(self.current_function_scope)
-                
+
                 prefix = '.'.join(filter(None, scope_parts))
-                qualified_var_name = f"{prefix}.{var_name_simple}" if prefix else var_name_simple
+                if prefix:
+                    var_name = f"{prefix}.{name_simple}"
+                else:
+                    var_name = name_simple
 
-                self.add_def(qualified_var_name, "variable", target_node.lineno)
+                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:
@@ -236,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)):
@@ -246,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:
-                            full_name_export = f"{self.mod}.{value}" if self.mod else value
-                            self.add_ref(full_name_export)
-                            self.add_ref(value) 
-        
+                            if self.mod:
+                                export_name = f"{self.mod}.{value}"
+                            else:
+                                export_name = value
+
+                            self.add_ref(export_name)
+                            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):
@@ -271,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)
@@ -283,32 +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):
+    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
-            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])
+                    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]):
+
+                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-1.2.2.dist-info → skylos-2.1.0.dist-info}/METADATA

@@ -1,8 +1,11 @@
 Metadata-Version: 2.4
 Name: skylos
-Version: 1.2.2
+Version: 2.1.0
 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.0
+Requires-Dist: flask-cors>=3.0.0
+Requires-Dist: libcst>=1.8.2
 Dynamic: requires-python

{skylos-1.2.2.dist-info → skylos-2.1.0.dist-info}/RECORD

@@ -1,10 +1,12 @@
-skylos/__init__.py,sha256=ZZWhq0TZ3G-yDi9inbYvMn8OBes-pqo1aYB5EivuxFI,152
-skylos/analyzer.py,sha256=cO6J-hOsdJLoyw2vkL2BdX_fS-i5R50suLuh1QqPly4,15144
-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
+skylos/__init__.py,sha256=sr_HNrjL2O7hbyh_8vN2tG1ZKw8sXJVegKjp3G8Iz9c,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=eX4oU0jQwDWejkkW4kjRNctre27sVLHK1CTDDiqPqRw,13054
+skylos/server.py,sha256=5Rlgy3LdE8I5TWRJJh0n19JqhVYaAOc9fUtRjL-PpX8,16270
+skylos/test_aware.py,sha256=kxYoMG2m02kbMlxtFOM-MWJO8qqxHviP9HgAMbKRfvU,2304
+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
@@ -12,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
@@ -25,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-1.2.2.dist-info/METADATA,sha256=2cvKXdg5thOkSpCbaN7jQ3Lwa10jVmVVB6KvDST3ZOw,224
-skylos-1.2.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-skylos-1.2.2.dist-info/entry_points.txt,sha256=zzRpN2ByznlQoLeuLolS_TFNYSQxUGBL1EXQsAd6bIA,43
-skylos-1.2.2.dist-info/top_level.txt,sha256=f8GA_7KwfaEopPMP8-EXDQXaqd4IbsOQPakZy01LkdQ,12
-skylos-1.2.2.dist-info/RECORD,,
+skylos-2.1.0.dist-info/METADATA,sha256=oE2audt2wkmDLNdDcZCHgmDxtrZY8gygMnDwI5Qi6V4,314
+skylos-2.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+skylos-2.1.0.dist-info/entry_points.txt,sha256=zzRpN2ByznlQoLeuLolS_TFNYSQxUGBL1EXQsAd6bIA,43
+skylos-2.1.0.dist-info/top_level.txt,sha256=f8GA_7KwfaEopPMP8-EXDQXaqd4IbsOQPakZy01LkdQ,12
+skylos-2.1.0.dist-info/RECORD,,