skylos 1.0.8__tar.gz → 1.0.10__tar.gz

{skylos-1.0.8 → skylos-1.0.10}/PKG-INFO

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

{skylos-1.0.8 → skylos-1.0.10}/pyproject.toml

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

{skylos-1.0.8 → skylos-1.0.10}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name="skylos",
-    version="1.0.8",
+    version="1.0.10",
     packages=find_packages(),
     python_requires=">=3.9",
     install_requires=["inquirer>=3.0.0"],

{skylos-1.0.8 → skylos-1.0.10}/skylos/__init__.py

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

{skylos-1.0.8 → skylos-1.0.10}/skylos/analyzer.py

@@ -26,7 +26,6 @@ class Skylos:
         return".".join(p)
     
     def _mark_exports(self):
-        
         for name, d in self.defs.items():
             if d.in_init and not d.simple_name.startswith('_'):
                 d.is_exported = True
@@ -71,7 +70,6 @@ class Skylos:
                 d.references += 1
     
     def _get_base_classes(self, class_name):
-        """Get base classes for a given class name"""
         if class_name not in self.defs:
             return []
         
@@ -83,7 +81,6 @@ class Skylos:
         return []
             
     def _apply_heuristics(self):
-
         class_methods=defaultdict(list)
         for d in self.defs.values():
             if d.type in("method","function") and"." in d.name:
@@ -97,17 +94,21 @@ class Skylos:
                     if m.simple_name in AUTO_CALLED:m.references+=1
                     
         for d in self.defs.values():
-            if d.simple_name in MAGIC_METHODS or d.simple_name.startswith("__")and d.simple_name.endswith("__"):d.confidence=0
-            if not d.simple_name.startswith("_")and d.type in("function","method","class"):d.confidence=min(d.confidence,90)
-            if d.in_init and d.type in("function","class"):d.confidence=min(d.confidence,85)
-            if d.name.split(".")[0] in self.dynamic:d.confidence=min(d.confidence,50)
-        
-        for d in self.defs.values():
+            if d.simple_name in MAGIC_METHODS or (d.simple_name.startswith("__") and d.simple_name.endswith("__")):
+                d.confidence = 0
+            
+            if not d.simple_name.startswith("_") and d.type in ("function", "method", "class"):
+                d.confidence = min(d.confidence, 90)
+            
+            if d.in_init and d.type in ("function", "class"):
+                d.confidence = min(d.confidence, 85)
+            
+            if d.name.split(".")[0] in self.dynamic:
+                d.confidence = min(d.confidence, 60)
+            
             if d.type == "method" and TEST_METHOD_PATTERN.match(d.simple_name):
-                # check if its in a class that inherits from a test base class
                 class_name = d.name.rsplit(".", 1)[0]
                 class_simple_name = class_name.split(".")[-1]
-                # class name suggests it's a test class, ignore test methods
                 if "Test" in class_simple_name or class_simple_name.endswith("TestCase"):
                     d.confidence = 0
 
@@ -134,9 +135,6 @@ class Skylos:
         self._apply_heuristics()
         self._mark_exports()
         
-        # for name, d in self.defs.items():
-        #     print(f"  {d.type} '{name}': {d.references} refs, exported: {d.is_exported}, confidence: {d.confidence}")
-            
         thr = max(0, thr)
 
         unused = []
@@ -144,7 +142,13 @@ class Skylos:
             if d.references == 0 and not d.is_exported and d.confidence >= thr:
                 unused.append(d.to_dict())
         
-        result = {"unused_functions": [], "unused_imports": [], "unused_classes": []}
+        result = {
+            "unused_functions": [], 
+            "unused_imports": [], 
+            "unused_classes": [],
+            "unused_variables": []
+        }
+        
         for u in unused:
             if u["type"] in ("function", "method"):
                 result["unused_functions"].append(u)
@@ -152,6 +156,8 @@ class Skylos:
                 result["unused_imports"].append(u)
             elif u["type"] == "class": 
                 result["unused_classes"].append(u)
+            elif u["type"] == "variable":
+                result["unused_variables"].append(u)
                 
         return json.dumps(result, indent=2)
 
@@ -175,6 +181,60 @@ def analyze(path,conf=60):return Skylos().analyze(path,conf)
 if __name__=="__main__":
     if len(sys.argv)>1:
         p=sys.argv[1];c=int(sys.argv[2])if len(sys.argv)>2 else 60
-        print(analyze(p,c))
+        result = analyze(p,c)
+        
+        data = json.loads(result)
+        print("\n🔍 Python Static Analysis Results")
+        print("===================================\n")
+        
+        total_items = sum(len(items) for items in data.values())
+        
+        print("Summary:")
+        if data["unused_functions"]:
+            print(f"  • Unreachable functions: {len(data['unused_functions'])}")
+        if data["unused_imports"]:
+            print(f"  • Unused imports: {len(data['unused_imports'])}")
+        if data["unused_classes"]:
+            print(f"  • Unused classes: {len(data['unused_classes'])}")
+        if data["unused_variables"]:
+            print(f"  • Unused variables: {len(data['unused_variables'])}")
+        
+        if data["unused_functions"]:
+            print("\n📦 Unreachable Functions")
+            print("=======================")
+            for i, func in enumerate(data["unused_functions"], 1):
+                print(f" {i}. {func['name']}")
+                print(f"    └─ {func['file']}:{func['line']}")
+        
+        if data["unused_imports"]:
+            print("\n📥 Unused Imports")
+            print("================")
+            for i, imp in enumerate(data["unused_imports"], 1):
+                print(f" {i}. {imp['simple_name']}")
+                print(f"    └─ {imp['file']}:{imp['line']}")
+        
+        if data["unused_classes"]:
+            print("\n📋 Unused Classes")
+            print("=================")
+            for i, cls in enumerate(data["unused_classes"], 1):
+                print(f" {i}. {cls['name']}")
+                print(f"    └─ {cls['file']}:{cls['line']}")
+                
+        if data["unused_variables"]:
+            print("\n📊 Unused Variables")
+            print("==================")
+            for i, var in enumerate(data["unused_variables"], 1):
+                print(f" {i}. {var['name']}")
+                print(f"    └─ {var['file']}:{var['line']}")
+        
+        print("\n" + "─" * 50)
+        print(f"Found {total_items} dead code items. Add this badge to your README:")
+        print(f"```markdown")
+        print(f"![Dead Code: {total_items}](https://img.shields.io/badge/Dead_Code-{total_items}_detected-orange?logo=codacy&logoColor=red)")
+        print(f"```")
+        
+        print("\nNext steps:")
+        print("  • Use --interactive to select specific items to remove")
+        print("  • Use --dry-run to preview changes before applying them")
     else:
         print("Usage: python Skylos.py <path> [confidence_threshold]")

{skylos-1.0.8 → skylos-1.0.10}/skylos/cli.py

@@ -24,9 +24,10 @@ class Colors:
     RESET = '\033[0m'
     GRAY = '\033[90m'
 
-class ColoredFormatter(logging.Formatter):
+class CleanFormatter(logging.Formatter):
+    """Custom formatter that removes timestamps and log levels for clean output"""
     def format(self, record):
-        return super().format(record)
+        return record.getMessage()
 
 def setup_logger(output_file=None):
     logger = logging.getLogger('skylos')
@@ -34,17 +35,20 @@ def setup_logger(output_file=None):
     
     logger.handlers.clear()
     
-    formatter = ColoredFormatter('%(message)s')
+    formatter = CleanFormatter()
     
     console_handler = logging.StreamHandler(sys.stdout)
     console_handler.setFormatter(formatter)
     logger.addHandler(console_handler)
     
     if output_file:
+        file_formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
         file_handler = logging.FileHandler(output_file)
-        file_handler.setFormatter(formatter)
+        file_handler.setFormatter(file_formatter)
         logger.addHandler(file_handler)
     
+    logger.propagate = False
+    
     return logger
 
 def remove_unused_import(file_path: str, import_name: str, line_number: int) -> bool:
@@ -176,6 +180,21 @@ def interactive_selection(logger, unused_functions, unused_imports):
     
     return selected_functions, selected_imports
 
+def print_badge(dead_code_count: int, logger):
+    """Print appropriate badge based on dead code count"""
+    logger.info(f"\n{Colors.GRAY}{'─' * 50}{Colors.RESET}")
+    
+    if dead_code_count == 0:
+        logger.info(f"✨ Your code is 100% dead code free! Add this badge to your README:")
+        logger.info("```markdown")
+        logger.info("![Dead Code Free](https://img.shields.io/badge/Dead_Code-Free-brightgreen?logo=moleculer&logoColor=white)")
+        logger.info("```")
+    else:
+        logger.info(f"Found {dead_code_count} dead code items. Add this badge to your README:")
+        logger.info("```markdown")  
+        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:
     parser = argparse.ArgumentParser(
         description="Detect unreachable functions and unused imports in a Python project"
@@ -224,109 +243,94 @@ def main() -> None:
 
     if args.json:
         logger.info(result_json)
-    else:
-        unused_functions = result.get("unused_functions", [])
-        unused_imports = result.get("unused_imports", [])
-        
-        logger.info(f"\n{Colors.CYAN}{Colors.BOLD}🔍 Python Static Analysis Results{Colors.RESET}")
-        logger.info(f"{Colors.CYAN}{'=' * 35}{Colors.RESET}")
-        
-        logger.info(f"\n{Colors.BOLD}Summary:{Colors.RESET}")
-        logger.info(f"  • Unreachable functions: {Colors.YELLOW}{len(unused_functions)}{Colors.RESET}")
-        logger.info(f"  • Unused imports: {Colors.YELLOW}{len(unused_imports)}{Colors.RESET}")
+        return
+
+    unused_functions = result.get("unused_functions", [])
+    unused_imports = result.get("unused_imports", [])
+    
+    logger.info(f"{Colors.CYAN}{Colors.BOLD}🔍 Python Static Analysis Results{Colors.RESET}")
+    logger.info(f"{Colors.CYAN}{'=' * 35}{Colors.RESET}")
+    
+    logger.info(f"\n{Colors.BOLD}Summary:{Colors.RESET}")
+    logger.info(f"  • Unreachable functions: {Colors.YELLOW}{len(unused_functions)}{Colors.RESET}")
+    logger.info(f"  • Unused imports: {Colors.YELLOW}{len(unused_imports)}{Colors.RESET}")
+    
+    if args.interactive and (unused_functions or unused_imports):
+        logger.info(f"\n{Colors.BOLD}Interactive Mode:{Colors.RESET}")
+        selected_functions, selected_imports = interactive_selection(logger, unused_functions, unused_imports)
         
-        if args.interactive and (unused_functions or unused_imports):
-            logger.info(f"\n{Colors.BOLD}Interactive Mode:{Colors.RESET}")
-            selected_functions, selected_imports = interactive_selection(logger, unused_functions, unused_imports)
+        if selected_functions or selected_imports:
+            logger.info(f"\n{Colors.BOLD}Selected items to remove:{Colors.RESET}")
+            
+            if selected_functions:
+                logger.info(f"  Functions: {len(selected_functions)}")
+                for func in selected_functions:
+                    logger.info(f"    - {func['name']} ({func['file']}:{func['line']})")
             
-            if selected_functions or selected_imports:
-                logger.info(f"\n{Colors.BOLD}Selected items to remove:{Colors.RESET}")
+            if selected_imports:
+                logger.info(f"  Imports: {len(selected_imports)}")
+                for imp in selected_imports:
+                    logger.info(f"    - {imp['name']} ({imp['file']}:{imp['line']})")
+            
+            if not args.dry_run:
+                questions = [
+                    inquirer.Confirm('confirm',
+                                   message="Are you sure you want to remove these items?",
+                                   default=False)
+                ]
+                answers = inquirer.prompt(questions)
                 
-                if selected_functions:
-                    logger.info(f"  Functions: {len(selected_functions)}")
+                if answers and answers['confirm']:
+                    logger.info(f"\n{Colors.YELLOW}Removing selected items...{Colors.RESET}")
+                    
                     for func in selected_functions:
-                        logger.info(f"    - {func['name']} ({func['file']}:{func['line']})")
-                
-                if selected_imports:
-                    logger.info(f"  Imports: {len(selected_imports)}")
+                        success = remove_unused_function(func['file'], func['name'], func['line'])
+                        if success:
+                            logger.info(f"  {Colors.GREEN}✓{Colors.RESET} Removed function: {func['name']}")
+                        else:
+                            logger.error(f"  {Colors.RED}✗{Colors.RESET} Failed to remove: {func['name']}")
+                    
                     for imp in selected_imports:
-                        logger.info(f"    - {imp['name']} ({imp['file']}:{imp['line']})")
-                
-                if not args.dry_run:
-                    questions = [
-                        inquirer.Confirm('confirm',
-                                       message="Are you sure you want to remove these items?",
-                                       default=False)
-                    ]
-                    answers = inquirer.prompt(questions)
+                        success = remove_unused_import(imp['file'], imp['name'], imp['line'])
+                        if success:
+                            logger.info(f"  {Colors.GREEN}✓{Colors.RESET} Removed import: {imp['name']}")
+                        else:
+                            logger.error(f"  {Colors.RED}✗{Colors.RESET} Failed to remove: {imp['name']}")
                     
-                    if answers and answers['confirm']:
-                        logger.info(f"\n{Colors.YELLOW}Removing selected items...{Colors.RESET}")
-                        
-                        for func in selected_functions:
-                            success = remove_unused_function(func['file'], func['name'], func['line'])
-                            if success:
-                                logger.info(f"  {Colors.GREEN}✓{Colors.RESET} Removed function: {func['name']}")
-                            else:
-                                logger.error(f"  {Colors.RED}✗{Colors.RESET} Failed to remove: {func['name']}")
-                        
-                        for imp in selected_imports:
-                            success = remove_unused_import(imp['file'], imp['name'], imp['line'])
-                            if success:
-                                logger.info(f"  {Colors.GREEN}✓{Colors.RESET} Removed import: {imp['name']}")
-                            else:
-                                logger.error(f"  {Colors.RED}✗{Colors.RESET} Failed to remove: {imp['name']}")
-                        
-                        logger.info(f"\n{Colors.GREEN}Cleanup complete!{Colors.RESET}")
-                    else:
-                        logger.info(f"\n{Colors.YELLOW}Operation cancelled.{Colors.RESET}")
+                    logger.info(f"\n{Colors.GREEN}Cleanup complete!{Colors.RESET}")
                 else:
-                    logger.info(f"\n{Colors.YELLOW}Dry run - no files were modified.{Colors.RESET}")
+                    logger.info(f"\n{Colors.YELLOW}Operation cancelled.{Colors.RESET}")
             else:
-                logger.info(f"\n{Colors.BLUE}No items selected.{Colors.RESET}")
+                logger.info(f"\n{Colors.YELLOW}Dry run - no files were modified.{Colors.RESET}")
+        else:
+            logger.info(f"\n{Colors.BLUE}No items selected.{Colors.RESET}")
+    
+    else:
+        if unused_functions:
+            logger.info(f"\n{Colors.RED}{Colors.BOLD}📦 Unreachable Functions{Colors.RESET}")
+            logger.info(f"{Colors.RED}{'=' * 23}{Colors.RESET}")
+            for i, item in enumerate(unused_functions, 1):
+                logger.info(f"{Colors.GRAY}{i:2d}. {Colors.RESET}{Colors.RED}{item['name']}{Colors.RESET}")
+                logger.info(f"    {Colors.GRAY}└─ {item['file']}:{item['line']}{Colors.RESET}")
+        else:
+            logger.info(f"\n{Colors.GREEN}✓ All functions are reachable!{Colors.RESET}")
         
+        if unused_imports:
+            logger.info(f"\n{Colors.MAGENTA}{Colors.BOLD}📥 Unused Imports{Colors.RESET}")
+            logger.info(f"{Colors.MAGENTA}{'=' * 16}{Colors.RESET}")
+            for i, item in enumerate(unused_imports, 1):
+                logger.info(f"{Colors.GRAY}{i:2d}. {Colors.RESET}{Colors.MAGENTA}{item['name']}{Colors.RESET}")
+                logger.info(f"    {Colors.GRAY}└─ {item['file']}:{item['line']}{Colors.RESET}")
         else:
-            if unused_functions:
-                logger.info(f"\n{Colors.RED}{Colors.BOLD}📦 Unreachable Functions{Colors.RESET}")
-                logger.info(f"{Colors.RED}{'=' * 23}{Colors.RESET}")
-                for i, item in enumerate(unused_functions, 1):
-                    logger.info(f"{Colors.GRAY}{i:2d}. {Colors.RESET}{Colors.RED}{item['name']}{Colors.RESET}")
-                    logger.info(f"    {Colors.GRAY}└─ {item['file']}:{item['line']}{Colors.RESET}")
-            else:
-                logger.info(f"\n{Colors.GREEN}✓ All functions are reachable!{Colors.RESET}")
-            
-            if unused_imports:
-                logger.info(f"\n{Colors.MAGENTA}{Colors.BOLD}📥 Unused Imports{Colors.RESET}")
-                logger.info(f"{Colors.MAGENTA}{'=' * 16}{Colors.RESET}")
-                for i, item in enumerate(unused_imports, 1):
-                    logger.info(f"{Colors.GRAY}{i:2d}. {Colors.RESET}{Colors.MAGENTA}{item['name']}{Colors.RESET}")
-                    logger.info(f"    {Colors.GRAY}└─ {item['file']}:{item['line']}{Colors.RESET}")
-            else:
-                logger.info(f"\n{Colors.GREEN}✓ All imports are being used!{Colors.RESET}")
-            
-            logger.info(f"\n{Colors.GRAY}{'─' * 50}{Colors.RESET}")
-            logger.info(f"{Colors.GRAY}Analysis complete.{Colors.RESET}")
-
-            logger.info(f"\n{Colors.GRAY}{'─' * 50}{Colors.RESET}")
-            logger.info(f"{Colors.GRAY}Analysis complete.{Colors.RESET}")
-
-            dead_code_count = len(unused_functions) + len(unused_imports)
-
-            if dead_code_count == 0:
-                logger.info(f"\n✨ Your code is 100% dead code free! Add this badge to your README:")
-                logger.info("```markdown")
-                logger.info("![Dead Code Free](https://img.shields.io/badge/Dead_Code-Free-brightgreen?logo=moleculer&logoColor=white)")
-                logger.info("```")
-            else:
-                logger.info(f"Found {dead_code_count} dead code items. Add this badge to your README:")
-                logger.info("```markdown")  
-                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("```")
+            logger.info(f"\n{Colors.GREEN}✓ All imports are being used!{Colors.RESET}")
+        
+        dead_code_count = len(unused_functions) + len(unused_imports)
+        print_badge(dead_code_count, logger)
 
-            if unused_functions or unused_imports:
-                logger.info(f"\n{Colors.BOLD}Next steps:{Colors.RESET}")
-                logger.info(f"  • Use --interactive to select specific items to remove")
-                logger.info(f"  • Use --dry-run to preview changes before applying them")
+        if unused_functions or unused_imports:
+            logger.info(f"\n{Colors.BOLD}Next steps:{Colors.RESET}")
+            logger.info(f"  • Use --interactive to select specific items to remove")
+            logger.info(f"  • Use --dry-run to preview changes before applying them")
 
 if __name__ == "__main__":
     main()

{skylos-1.0.8 → skylos-1.0.10}/skylos/visitor.py

@@ -62,7 +62,23 @@ class Visitor(ast.NodeVisitor):
         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
-    
+
+    def visit_annotation(self, node):
+        if node is not None:
+            if isinstance(node, ast.Constant) and isinstance(node.value, str):
+                self.visit_string_annotation(node.value)
+            elif hasattr(node, 's') and isinstance(node.s, str):
+                self.visit_string_annotation(node.s)
+            else:
+                self.visit(node)
+
+    def visit_string_annotation(self, annotation_str):
+        try:
+            parsed = ast.parse(annotation_str, mode='eval')
+            self.visit(parsed.body)
+        except:
+            pass
+
     def visit_Import(self,node):
         for a in node.names:
             full=a.name
@@ -81,6 +97,23 @@ class Visitor(ast.NodeVisitor):
             self.alias[a.asname or a.name]=full
             self.add_def(full,"import",node.lineno)
 
+    def visit_arguments(self, args):
+        for arg in args.args:
+            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:
+            self.visit_annotation(args.vararg.annotation)
+        if args.kwarg:
+            self.visit_annotation(args.kwarg.annotation)
+        for default in args.defaults:
+            self.visit(default)
+        for default in args.kw_defaults:
+            if default:
+                self.visit(default)
+
     def visit_FunctionDef(self,node):
         outer_scope_prefix = '.'.join(self.current_function_scope) + '.' if self.current_function_scope else ''
         
@@ -94,8 +127,13 @@ class Visitor(ast.NodeVisitor):
         self.add_def(qualified_name,"method"if self.cls else"function",node.lineno)
         
         self.current_function_scope.append(node.name)
+        
         for d_node in node.decorator_list:
             self.visit(d_node)
+        
+        self.visit_arguments(node.args)
+        self.visit_annotation(node.returns)
+        
         for stmt in node.body:
             self.visit(stmt)
         self.current_function_scope.pop()
@@ -105,10 +143,40 @@ class Visitor(ast.NodeVisitor):
     def visit_ClassDef(self,node):
         cname=f"{self.mod}.{node.name}"
         self.add_def(cname,"class",node.lineno)
+        
+        for base in node.bases:
+            self.visit(base)
+        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
 
+    def visit_AnnAssign(self, node):
+        self.visit_annotation(node.annotation)
+        if node.value:
+            self.visit(node.value)
+        self.visit(node.target)
+
+    def visit_AugAssign(self, node):
+        self.visit(node.target)
+        self.visit(node.value)
+
+    def visit_Subscript(self, node):
+        self.visit(node.value)
+        self.visit(node.slice)
+
+    def visit_Slice(self, node):
+        if node.lower:
+            self.visit(node.lower)
+        if node.upper:
+            self.visit(node.upper)
+        if node.step:
+            self.visit(node.step)
+
     def visit_Assign(self, node):
         for target in node.targets:
             if isinstance(target, ast.Name) and target.id == "__all__":
@@ -148,16 +216,6 @@ 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.Attribute) and 
-            node.func.attr == "format" and 
-            isinstance(node.func.value, ast.Constant) and 
-            isinstance(node.func.value.value, str)):
-            fmt = node.func.value.value
-            if any(isinstance(k.arg, str) and k.arg is None for k in node.keywords):
-                for _, n, _, _ in re.findall(r'\{([^}:!]+)', fmt):
-                    if n:
-                        self.add_ref(self.qual(n))
 
     def visit_Name(self,node):
         if isinstance(node.ctx,ast.Load):
@@ -169,6 +227,20 @@ class Visitor(ast.NodeVisitor):
         if isinstance(node.ctx,ast.Load)and isinstance(node.value,ast.Name):
             self.add_ref(f"{self.qual(node.value.id)}.{node.attr}")
 
+    def visit_keyword(self, node):
+        self.visit(node.value)
+
+    def visit_withitem(self, node):
+        self.visit(node.context_expr)
+        if node.optional_vars:
+            self.visit(node.optional_vars)
+
+    def visit_ExceptHandler(self, node):
+        if node.type:
+            self.visit(node.type)
+        for stmt in node.body:
+            self.visit(stmt)
+
     def generic_visit(self, node):
         for field, value in ast.iter_fields(node):
             if isinstance(value, list):

{skylos-1.0.8 → skylos-1.0.10}/skylos.egg-info/PKG-INFO

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