skylos 1.0.7__tar.gz → 1.0.9__tar.gz

{skylos-1.0.7 → skylos-1.0.9}/PKG-INFO

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

{skylos-1.0.7 → skylos-1.0.9}/README.md

@@ -171,6 +171,9 @@ A: They test common scenarios but can't cover every edge case. Use them as a gui
 **Q: Should I automatically delete everything flagged as unused?**
 A: No. Always review results manually, especially for framework code, APIs, and test utilities.
 
+**Q: Why did Ruff underperform?**
+A: Like all other tools, Ruff is focused on detecting specific, surface-level issues. Tools like Vulture and Skylos are built SPECIFICALLY for dead code detection. It is NOT a specialized dead code detector. If your goal is dead code, then ruff is the wrong tool. It is a good tool but it's like using a wrench to hammer a nail. Good tool, wrong purpose. 
+
 ## Limitations
 
 - **Dynamic code**: `getattr()`, `globals()`, runtime imports are hard to detect

{skylos-1.0.7 → skylos-1.0.9}/pyproject.toml

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

{skylos-1.0.7 → skylos-1.0.9}/setup.py

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

{skylos-1.0.7 → skylos-1.0.9}/skylos/__init__.py

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

{skylos-1.0.7 → skylos-1.0.9}/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.7 → skylos-1.0.9}/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.7 → skylos-1.0.9}/skylos.egg-info/PKG-INFO

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