skylos 1.0.7__py3-none-any.whl

skylos/__init__.py

@@ -0,0 +1,8 @@
+from skylos.analyzer import analyze
+
+__version__ = "1.0.7"
+
+def debug_test():
+    return "debug-ok"
+
+__all__ = ["analyze", "debug_test", "__version__"]

skylos/analyzer.py

@@ -0,0 +1,180 @@
+#!/usr/bin/env python3
+import ast,sys,json,logging,re
+from pathlib import Path
+from collections import defaultdict
+from skylos.visitor import Visitor
+
+logging.basicConfig(level=logging.INFO,format='%(asctime)s - %(levelname)s - %(message)s')
+logger=logging.getLogger('Skylos')
+
+AUTO_CALLED={"__init__","__enter__","__exit__"}
+TEST_BASE_CLASSES = {"TestCase", "AsyncioTestCase", "unittest.TestCase", "unittest.AsyncioTestCase"}
+TEST_METHOD_PATTERN = re.compile(r"^test_\w+$")
+MAGIC_METHODS={f"__{n}__"for n in["init","new","call","getattr","getattribute","enter","exit","str","repr","hash","eq","ne","lt","gt","le","ge","iter","next","contains","len","getitem","setitem","delitem","iadd","isub","imul","itruediv","ifloordiv","imod","ipow","ilshift","irshift","iand","ixor","ior","round","format","dir","abs","complex","int","float","bool","bytes","reduce","await","aiter","anext","add","sub","mul","truediv","floordiv","mod","divmod","pow","lshift","rshift","and","or","xor","radd","rsub","rmul","rtruediv","rfloordiv","rmod","rdivmod","rpow","rlshift","rrshift","rand","ror","rxor"]}
+
+class Skylos:
+    def __init__(self):
+        self.defs={}
+        self.refs=[]
+        self.dynamic=set()
+        self.exports=defaultdict(set)
+
+    def _module(self,root,f):
+        p=list(f.relative_to(root).parts)
+        if p[-1].endswith(".py"):p[-1]=p[-1][:-3]
+        if p[-1]=="__init__":p.pop()
+        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
+        
+        for mod, export_names in self.exports.items():
+            for name in export_names:
+                for def_name, def_obj in self.defs.items():
+                    if (def_name.startswith(f"{mod}.") and 
+                        def_obj.simple_name == name and
+                        def_obj.type != "import"):
+                        def_obj.is_exported = True
+
+    def _mark_refs(self):
+        import_to_original = {}
+        for name, def_obj in self.defs.items():
+            if def_obj.type == "import":
+                import_name = name.split('.')[-1]
+                
+                for def_name, orig_def in self.defs.items():
+                    if (orig_def.type != "import" and 
+                        orig_def.simple_name == import_name and
+                        def_name != name):
+                        import_to_original[name] = def_name
+                        break
+
+        simple_name_lookup = defaultdict(list)
+        for d in self.defs.values():
+            simple_name_lookup[d.simple_name].append(d)
+        
+        for ref, file in self.refs:
+            if ref in self.defs:
+                self.defs[ref].references += 1
+                
+                if ref in import_to_original:
+                    original = import_to_original[ref]
+                    self.defs[original].references += 1
+                continue
+            
+            simple = ref.split('.')[-1]
+            matches = simple_name_lookup.get(simple, [])
+            for d in matches:
+                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 []
+        
+        class_def = self.defs[class_name]
+        
+        if hasattr(class_def, 'base_classes'):
+            return class_def.base_classes
+        
+        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:
+                cls=d.name.rsplit(".",1)[0]
+                if cls in self.defs and self.defs[cls].type=="class":
+                    class_methods[cls].append(d)
+
+        for cls,methods in class_methods.items():
+            if self.defs[cls].references>0:
+                for m in methods:
+                    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.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
+
+    def analyze(self, path, thr=60):
+        p = Path(path).resolve()
+        files = [p] if p.is_file() else list(p.glob("**/*.py"))
+        root = p.parent if p.is_file() else p
+        
+        modmap = {}
+        for f in files:
+            modmap[f] = self._module(root, f)
+        
+        for file in files:
+            mod = modmap[file]
+            defs, refs, dyn, exports = proc_file(file, mod)
+            
+            for d in defs: 
+                self.defs[d.name] = d
+            self.refs.extend(refs)
+            self.dynamic.update(dyn)
+            self.exports[mod].update(exports)
+        
+        self._mark_refs()
+        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 = []
+        for d in self.defs.values():
+            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": []}
+        for u in unused:
+            if u["type"] in ("function", "method"):
+                result["unused_functions"].append(u)
+            elif u["type"] == "import":
+                result["unused_imports"].append(u)
+            elif u["type"] == "class": 
+                result["unused_classes"].append(u)
+                
+        return json.dumps(result, indent=2)
+
+def proc_file(file_or_args, mod=None):
+    if mod is None and isinstance(file_or_args, tuple):
+        file, mod = file_or_args 
+    else:
+        file = file_or_args 
+
+    try:
+        tree = ast.parse(Path(file).read_text(encoding="utf-8"))
+        v = Visitor(mod, file)
+        v.visit(tree)
+        return v.defs, v.refs, v.dyn, v.exports
+    except Exception as e:
+        logger.error(f"{file}: {e}")
+        return [], [], set(), set()
+
+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))
+    else:
+        print("Usage: python Skylos.py <path> [confidence_threshold]")

skylos/cli.py

@@ -0,0 +1,332 @@
+import argparse
+import json
+import sys
+import logging
+import ast
+import skylos
+
+try:
+    import inquirer
+    INTERACTIVE_AVAILABLE = True
+except ImportError:
+    INTERACTIVE_AVAILABLE = False
+
+class Colors:
+    RED = '\033[91m'
+    GREEN = '\033[92m'
+    YELLOW = '\033[93m'
+    BLUE = '\033[94m'
+    MAGENTA = '\033[95m'
+    CYAN = '\033[96m'
+    WHITE = '\033[97m'
+    BOLD = '\033[1m'
+    UNDERLINE = '\033[4m'
+    RESET = '\033[0m'
+    GRAY = '\033[90m'
+
+class ColoredFormatter(logging.Formatter):
+    def format(self, record):
+        return super().format(record)
+
+def setup_logger(output_file=None):
+    logger = logging.getLogger('skylos')
+    logger.setLevel(logging.INFO)
+    
+    logger.handlers.clear()
+    
+    formatter = ColoredFormatter('%(message)s')
+    
+    console_handler = logging.StreamHandler(sys.stdout)
+    console_handler.setFormatter(formatter)
+    logger.addHandler(console_handler)
+    
+    if output_file:
+        file_handler = logging.FileHandler(output_file)
+        file_handler.setFormatter(formatter)
+        logger.addHandler(file_handler)
+    
+    return logger
+
+def remove_unused_import(file_path: str, import_name: str, line_number: int) -> bool:
+    try:
+        with open(file_path, 'r') as f:
+            lines = f.readlines()
+        
+        line_idx = line_number - 1
+        original_line = lines[line_idx].strip()
+        
+        if original_line.startswith(f'import {import_name}'):
+            lines[line_idx] = ''
+        elif original_line.startswith('import ') and f' {import_name}' in original_line:
+            parts = original_line.split(' ', 1)[1].split(',')
+            new_parts = [p.strip() for p in parts if p.strip() != import_name]
+            if new_parts:
+                lines[line_idx] = f'import {", ".join(new_parts)}\n'
+            else:
+                lines[line_idx] = ''
+        elif original_line.startswith('from ') and import_name in original_line:
+            if f'import {import_name}' in original_line and ',' not in original_line:
+                lines[line_idx] = ''
+            else:
+                parts = original_line.split('import ', 1)[1].split(',')
+                new_parts = [p.strip() for p in parts if p.strip() != import_name]
+                if new_parts:
+                    prefix = original_line.split(' import ')[0]
+                    lines[line_idx] = f'{prefix} import {", ".join(new_parts)}\n'
+                else:
+                    lines[line_idx] = ''
+        
+        with open(file_path, 'w') as f:
+            f.writelines(lines)
+        
+        return True
+    except Exception as e:
+        logging.error(f"Failed to remove import {import_name} from {file_path}: {e}")
+        return False
+
+def remove_unused_function(file_path: str, function_name: str, line_number: int) -> bool:
+    try:
+        with open(file_path, 'r') as f:
+            content = f.read()
+        
+        tree = ast.parse(content)
+        
+        lines = content.splitlines()
+        for node in ast.walk(tree):
+            if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+                if (node.name in function_name and 
+                    node.lineno == line_number):
+                    
+                    start_line = node.lineno - 1
+                    
+                    if node.decorator_list:
+                        start_line = node.decorator_list[0].lineno - 1
+                    
+                    end_line = len(lines)
+                    base_indent = len(lines[start_line]) - len(lines[start_line].lstrip())
+                    
+                    for i in range(node.end_lineno, len(lines)):
+                        if lines[i].strip() == '':
+                            continue
+                        current_indent = len(lines[i]) - len(lines[i].lstrip())
+                        if current_indent <= base_indent and lines[i].strip():
+                            end_line = i
+                            break
+                    
+                    while end_line < len(lines) and lines[end_line].strip() == '':
+                        end_line += 1
+                    
+                    new_lines = lines[:start_line] + lines[end_line:]
+                    
+                    with open(file_path, 'w') as f:
+                        f.write('\n'.join(new_lines) + '\n')
+                    
+                    return True
+        
+        return False
+    except Exception as e:
+        logging.error(f"Failed to remove function {function_name} from {file_path}: {e}")
+        return False
+
+def interactive_selection(logger, unused_functions, unused_imports):
+    if not INTERACTIVE_AVAILABLE:
+        logger.error("Interactive mode requires 'inquirer' package. Install with: pip install inquirer")
+        return [], []
+    
+    selected_functions = []
+    selected_imports = []
+    
+    if unused_functions:
+        logger.info(f"\n{Colors.CYAN}{Colors.BOLD}Select unused functions to remove:{Colors.RESET}")
+        
+        function_choices = []
+        for item in unused_functions:
+            choice_text = f"{item['name']} ({item['file']}:{item['line']})"
+            function_choices.append((choice_text, item))
+        
+        questions = [
+            inquirer.Checkbox('functions',
+                            message="Select functions to remove",
+                            choices=function_choices,
+                            )
+        ]
+        
+        answers = inquirer.prompt(questions)
+        if answers:
+            selected_functions = answers['functions']
+    
+    if unused_imports:
+        logger.info(f"\n{Colors.MAGENTA}{Colors.BOLD}Select unused imports to remove:{Colors.RESET}")
+        
+        import_choices = []
+        for item in unused_imports:
+            choice_text = f"{item['name']} ({item['file']}:{item['line']})"
+            import_choices.append((choice_text, item))
+        
+        questions = [
+            inquirer.Checkbox('imports',
+                            message="Select imports to remove",
+                            choices=import_choices,
+                            )
+        ]
+        
+        answers = inquirer.prompt(questions)
+        if answers:
+            selected_imports = answers['imports']
+    
+    return selected_functions, selected_imports
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        description="Detect unreachable functions and unused imports in a Python project"
+    )
+    parser.add_argument("path", help="Path to the Python project to analyze")
+    parser.add_argument(
+        "--json",
+        action="store_true",
+        help="Output raw JSON instead of formatted text",
+    )
+    parser.add_argument(
+        "--output",
+        "-o",
+        type=str,
+        help="Write output to file instead of stdout",
+    )
+    parser.add_argument(
+        "--verbose", "-v",
+        action="store_true",
+        help="Enable verbose output"
+    )
+    parser.add_argument(
+        "--interactive", "-i",
+        action="store_true",
+        help="Interactively select items to remove (requires inquirer)"
+    )
+    parser.add_argument(
+        "--dry-run",
+        action="store_true",
+        help="Show what would be removed without actually modifying files"
+    )
+
+    args = parser.parse_args()
+    logger = setup_logger(args.output)
+    
+    if args.verbose:
+        logger.setLevel(logging.DEBUG)
+        logger.debug(f"Analyzing path: {args.path}")
+
+    try:
+        result_json = skylos.analyze(args.path)
+        result = json.loads(result_json)
+    except Exception as e:
+        logger.error(f"Error during analysis: {e}")
+        sys.exit(1)
+
+    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}")
+        
+        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_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 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}")
+                else:
+                    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:
+                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("```")
+
+            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()