skylos 1.0.11__py3-none-any.whl → 1.1.11__py3-none-any.whl

skylos/__init__.py

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

skylos/analyzer.py

@@ -8,10 +8,39 @@ logging.basicConfig(level=logging.INFO,format='%(asctime)s - %(levelname)s - %(m
 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"]}
 
+DEFAULT_EXCLUDE_FOLDERS = {
+    "__pycache__",
+    ".git", 
+    ".pytest_cache",
+    ".mypy_cache",
+    ".tox",
+    "htmlcov",
+    ".coverage",
+    "build",
+    "dist",
+    "*.egg-info",
+    "venv",
+    ".venv"
+}
+
+def parse_exclude_folders(user_exclude_folders, use_defaults=True, include_folders=None):
+    exclude_set = set()
+    
+    if use_defaults:
+        exclude_set.update(DEFAULT_EXCLUDE_FOLDERS)
+        
+    if user_exclude_folders:
+        exclude_set.update(user_exclude_folders)
+    
+    if include_folders:
+        for folder in include_folders:
+            exclude_set.discard(folder)
+    
+    return exclude_set
+
 class Skylos:
     def __init__(self):
         self.defs={}
@@ -25,6 +54,54 @@ class Skylos:
         if p[-1]=="__init__":p.pop()
         return".".join(p)
     
+    def _should_exclude_file(self, file_path, root_path, exclude_folders):
+        if not exclude_folders:
+            return False
+            
+        try:
+            rel_path = file_path.relative_to(root_path)
+        except ValueError:
+            return False
+        
+        path_parts = rel_path.parts
+        
+        for exclude_folder in exclude_folders:
+            if "*" in exclude_folder:
+                for part in path_parts:
+                    if part.endswith(exclude_folder.replace("*", "")):
+                        return True
+            else:
+                if exclude_folder in path_parts:
+                    return True
+        
+        return False
+    
+    def _get_python_files(self, path, exclude_folders=None):
+        p = Path(path).resolve()
+        
+        if p.is_file():
+            return [p], p.parent
+        
+        root = p
+        all_files = list(p.glob("**/*.py"))
+        
+        if exclude_folders:
+            filtered_files = []
+            excluded_count = 0
+            
+            for file_path in all_files:
+                if self._should_exclude_file(file_path, root, exclude_folders):
+                    excluded_count += 1
+                    continue
+                filtered_files.append(file_path)
+            
+            if excluded_count > 0:
+                logger.info(f"Excluded {excluded_count} files from analysis")
+            
+            return filtered_files, root
+        
+        return all_files, root
+    
     def _mark_exports(self):
         for name, d in self.defs.items():
             if d.in_init and not d.simple_name.startswith('_'):
@@ -55,7 +132,7 @@ class Skylos:
         for d in self.defs.values():
             simple_name_lookup[d.simple_name].append(d)
         
-        for ref, file in self.refs:
+        for ref, _ in self.refs:
             if ref in self.defs:
                 self.defs[ref].references += 1
                 
@@ -118,13 +195,30 @@ class Skylos:
             if d.type == "method" and TEST_METHOD_PATTERN.match(d.simple_name):
                 class_name = d.name.rsplit(".", 1)[0]
                 class_simple_name = class_name.split(".")[-1]
-                if "Test" in class_simple_name or class_simple_name.endswith("TestCase"):
+                if (class_simple_name.startswith("Test") or 
+                    class_simple_name.endswith("Test") 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
+    def analyze(self, path, thr=60, exclude_folders=None):
+        
+        files, root = self._get_python_files(path, exclude_folders)
+        
+        if not files:
+            logger.warning(f"No Python files found in {path}")
+            return json.dumps({
+                "unused_functions": [], 
+                "unused_imports": [], 
+                "unused_classes": [],
+                "unused_variables": [],
+                "unused_parameters": [],
+                 "analysis_summary": {
+                    "total_files": 0,
+                    "excluded_folders": exclude_folders if exclude_folders else []
+                }
+            })
+        
+        logger.info(f"Analyzing {len(files)} Python files...")
         
         modmap = {}
         for f in files:
@@ -156,7 +250,11 @@ class Skylos:
             "unused_imports": [], 
             "unused_classes": [],
             "unused_variables": [],
-            "unused_parameters": []
+            "unused_parameters": [],
+            "analysis_summary": {
+                "total_files": len(files),
+                "excluded_folders": exclude_folders if exclude_folders else [],
+            }
         }
         
         for u in unused:
@@ -188,7 +286,8 @@ def proc_file(file_or_args, mod=None):
         logger.error(f"{file}: {e}")
         return [], [], set(), set()
 
-def analyze(path,conf=60):return Skylos().analyze(path,conf)
+def analyze(path,conf=60, exclude_folders=None):
+    return Skylos().analyze(path,conf, exclude_folders)
 
 if __name__=="__main__":
     if len(sys.argv)>1:

skylos/cli.py

@@ -4,6 +4,7 @@ import sys
 import logging
 import ast
 import skylos
+from skylos.analyzer import parse_exclude_folders, DEFAULT_EXCLUDE_FOLDERS
 
 try:
     import inquirer
@@ -89,6 +90,7 @@ def remove_unused_import(file_path: str, import_name: str, line_number: int) ->
         return False
 
 def remove_unused_function(file_path: str, function_name: str, line_number: int) -> bool:
+    # remove the entire def from the source code
     try:
         with open(file_path, 'r') as f:
             content = f.read()
@@ -226,17 +228,74 @@ def main() -> None:
         action="store_true",
         help="Show what would be removed without actually modifying files"
     )
+    
+    parser.add_argument(
+        "--exclude-folder",
+        action="append",
+        dest="exclude_folders",
+        help="Exclude a folder from analysis (can be used multiple times). "
+             "By default, common folders like __pycache__, .git, venv are excluded. "
+             "Use --no-default-excludes to disable default exclusions."
+    )
+    
+    parser.add_argument(
+        "--include-folder", 
+        action="append",
+        dest="include_folders",
+        help="Force include a folder that would otherwise be excluded "
+             "(overrides both default and custom exclusions). "
+             "Example: --include-folder venv to scan your venv folder."
+    )
+    
+    parser.add_argument(
+        "--no-default-excludes",
+        action="store_true",
+        help="Don't exclude default folders (__pycache__, .git, venv, etc.). "
+             "Only exclude folders specified with --exclude-folder."
+    )
+    
+    parser.add_argument(
+        "--list-default-excludes",
+        action="store_true", 
+        help="List the default excluded folders and exit."
+    )
 
     args = parser.parse_args()
+
+    if args.list_default_excludes:
+        print("Default excluded folders:")
+        for folder in sorted(DEFAULT_EXCLUDE_FOLDERS):
+            print(f"  {folder}")
+        print(f"\nTotal: {len(DEFAULT_EXCLUDE_FOLDERS)} folders")
+        print("\nUse --no-default-excludes to disable these exclusions")
+        print("Use --include-folder <folder> to force include specific folders")
+        return
+    
     logger = setup_logger(args.output)
     
     if args.verbose:
         logger.setLevel(logging.DEBUG)
         logger.debug(f"Analyzing path: {args.path}")
+        if args.exclude_folders:
+            logger.debug(f"Excluding folders: {args.exclude_folders}")
+
+    use_defaults = not args.no_default_excludes
+    final_exclude_folders = parse_exclude_folders(
+        user_exclude_folders=args.exclude_folders,
+        use_defaults=use_defaults,
+        include_folders=args.include_folders
+    )
+    
+    if not args.json:
+        if final_exclude_folders:
+            logger.info(f"{Colors.YELLOW}📁 Excluding: {', '.join(sorted(final_exclude_folders))}{Colors.RESET}")
+        else:
+            logger.info(f"{Colors.GREEN}📁 No folders excluded{Colors.RESET}")
 
     try:
-        result_json = skylos.analyze(args.path)
+        result_json = skylos.analyze(args.path, exclude_folders=list(final_exclude_folders))
         result = json.loads(result_json)
+
     except Exception as e:
         logger.error(f"Error during analysis: {e}")
         sys.exit(1)
@@ -259,7 +318,6 @@ def main() -> None:
     logger.info(f"  • Unused parameters: {Colors.YELLOW}{len(unused_parameters)}{Colors.RESET}")
     logger.info(f"  • Unused variables: {Colors.YELLOW}{len(unused_variables)}{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)
@@ -352,8 +410,9 @@ def main() -> None:
 
         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")
+            logger.info(f" • Use --interactive to select specific items to remove")
+            logger.info(f" • Use --dry-run to preview changes before applying them")
+            logger.info(f" • Use --exclude-folder to skip directories like node_modules, .git")
 
 if __name__ == "__main__":
     main()

skylos/visitor.py

@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-import ast,re
+import ast
 from pathlib import Path
 
 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"}
@@ -98,16 +98,13 @@ class Visitor(ast.NodeVisitor):
                 base = ".".join(parts[:-node.level]) + (f".{node.module}" if node.module else "")
             
             full = f"{base}.{a.name}"
-            
             if a.asname:
-                alias_full = f"{self.mod}.{a.asname}" if self.mod else a.asname
-                self.add_def(alias_full, "import", node.lineno)
                 self.alias[a.asname] = full
-                self.add_ref(full)
+                self.add_def(full, "import", node.lineno)
             else:
                 self.alias[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)
@@ -271,7 +268,8 @@ class Visitor(ast.NodeVisitor):
                     break
             else:
                 # not parameter, handle normally
-                self.add_ref(self.qual(node.id))
+                qualified = self.qual(node.id)
+                self.add_ref(qualified)
                 if node.id in DYNAMIC_PATTERNS:
                     self.dyn.add(self.mod.split(".")[0])
 

{skylos-1.0.11.dist-info → skylos-1.1.11.dist-info}/METADATA

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

skylos-1.1.11.dist-info/RECORD

@@ -0,0 +1,25 @@
+skylos/__init__.py,sha256=ZZWhq0TZ3G-yDi9inbYvMn8OBes-pqo1aYB5EivuxFI,152
+skylos/analyzer.py,sha256=sXLvtJ3AB946HWV9JpDiWJ4-qwcT1cKRTA3TVTx2VNU,13117
+skylos/cli.py,sha256=7lcRFc3zailK2cPCWk6yT-EF0oeY_CmBo6TyD5m6c5Y,17355
+skylos/visitor.py,sha256=0h07CNS6RnWi3vMjWO0sexzePRXIAfPjQib8Qxu11oY,11740
+test/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+test/compare_tools.py,sha256=0g9PDeJlbst-7hOaQzrL4MiJFQKpqM8q8VeBGzpPczg,22738
+test/conftest.py,sha256=57sTF6vLL5U0CVKwGQFJcRs6n7t1dEHIriQoSluNmAI,6418
+test/diagnostics.py,sha256=ExuFOCVpc9BDwNYapU96vj9RXLqxji32Sv6wVF4nJYU,13802
+test/test_analyzer.py,sha256=uHcOJjW-LDryDLFRIZgVa4TgDv2JGrUo0HPsMwh4E8I,19720
+test/test_cli.py,sha256=rtdKzanDRJT_F92jKkCQFdhvlfwVJxfXKO8Hrbn-mIg,13180
+test/test_integration.py,sha256=bNKGUe-w0xEZEdnoQNHbssvKMGs9u9fmFQTOz1lX9_k,12398
+test/test_skylos.py,sha256=kz77STrS4k3Eez5RDYwGxOg2WH3e7zNZPUYEaTLbGTs,15608
+test/test_visitor.py,sha256=sybUQtALlwl6-Nec1TalB5O6ekO9Tfia0JJZDtA7Cwc,23272
+test/sample_repo/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+test/sample_repo/app.py,sha256=M5XgoAn-LPz50mKAj_ZacRKf-Pg7I4HbjWP7Z9jE4a0,226
+test/sample_repo/sample_repo/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+test/sample_repo/sample_repo/commands.py,sha256=b6gQ9YDabt2yyfqGbOpLo0osF7wya8O4Lm7m8gtCr3g,2575
+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.1.11.dist-info/METADATA,sha256=LUAqpC_E7ouGZxVtjyFa1LEXrTfV8MOyrQGRnDLnHYM,225
+skylos-1.1.11.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+skylos-1.1.11.dist-info/entry_points.txt,sha256=zzRpN2ByznlQoLeuLolS_TFNYSQxUGBL1EXQsAd6bIA,43
+skylos-1.1.11.dist-info/top_level.txt,sha256=f8GA_7KwfaEopPMP8-EXDQXaqd4IbsOQPakZy01LkdQ,12
+skylos-1.1.11.dist-info/RECORD,,

test/conftest.py

@@ -0,0 +1,212 @@
+import pytest
+import tempfile
+from pathlib import Path
+from textwrap import dedent
+
+@pytest.fixture(scope="session")
+def sample_project():
+    with tempfile.TemporaryDirectory() as temp_dir:
+        project_path = Path(temp_dir)
+        
+        create_sample_project(project_path)
+        yield project_path
+
+def create_sample_project(base_path: Path):
+    
+    (base_path / "app").mkdir()
+    
+    app_init = base_path / "app" / "__init__.py"
+    app_init.write_text(dedent("""
+        from .core import main_function
+        from .utils import helper_function
+        
+        __all__ = ['main_function', 'helper_function']
+    """))
+    
+    core_py = base_path / "app" / "core.py"
+    core_py.write_text(dedent("""
+        import os
+        import sys
+        from typing import Dict, List  # List is unused here
+        from collections import defaultdict
+        
+        def main_function():
+            '''Main entry point - should not be flagged'''
+            data = defaultdict(list)
+            return process_data(data)
+        
+        def process_data(data: Dict):
+            '''Used by main_function'''
+            return len(data)
+        
+        def deprecated_function():
+            '''This function is never called'''
+            unused_var = "should be flagged"
+            return unused_var
+        
+        def _private_helper():
+            '''Private function, might be unused'''
+            return "private"
+    """))
+    
+    utils_py = base_path / "app" / "utils.py" 
+    utils_py.write_text(dedent("""
+        import json  # unused
+        import re
+        
+        def helper_function():
+            '''Exported function'''
+            return validate_input("test")
+        
+        def validate_input(text: str):
+            '''Used by helper_function'''
+            return re.match(r"^[a-z]+$", text) is not None
+        
+        def unused_utility():
+            '''Never called utility'''
+            return "utility"
+        
+        class ConfigManager:
+            '''Used class'''
+            def __init__(self):
+                self.config = {}
+            
+            def get(self, key):
+                return self.config.get(key)
+        
+        class LegacyProcessor:
+            '''Unused class'''
+            def process(self, data):
+                return data
+    """))
+    
+    tests_dir = base_path / "tests"
+    tests_dir.mkdir()
+    
+    test_core = tests_dir / "test_core.py"
+    test_core.write_text(dedent("""
+        import unittest
+        from app.core import main_function, process_data
+        
+        class TestCore(unittest.TestCase):
+            def test_main_function(self):
+                result = main_function()
+                self.assertIsInstance(result, int)
+            
+            def test_process_data(self):
+                data = {'key': ['value']}
+                result = process_data(data)
+                self.assertEqual(result, 1)
+            
+            def test_edge_case(self):
+                '''Test methods should not be flagged'''
+                pass
+    """))
+    
+    config_dir = base_path / "config"
+    config_dir.mkdir()
+    
+    config_py = config_dir / "settings.py"
+    config_py.write_text(dedent("""
+        # Configuration file with potentially unused imports
+        import os
+        import logging
+        
+        DEBUG = True
+        DATABASE_URL = os.getenv("DATABASE_URL", "sqlite:///app.db")
+        
+        def setup_logging():
+            '''Might be called externally'''
+            logging.basicConfig(level=logging.INFO)
+    """))
+    
+    pycache_dir = base_path / "__pycache__"
+    pycache_dir.mkdir()
+    
+    cache_file = pycache_dir / "cached.pyc"
+    cache_file.write_bytes(b"fake compiled python")
+
+
+@pytest.fixture
+def simple_python_file():
+    with tempfile.NamedTemporaryFile(mode='w', suffix='.py', delete=False) as f:
+        f.write(dedent("""
+            import os  # unused
+            import sys
+            
+            def used_function():
+                print("Hello", file=sys.stderr)
+            
+            def unused_function():
+                return "never called"
+            
+            if __name__ == "__main__":
+                used_function()
+        """))
+        f.flush()
+        yield Path(f.name)
+        Path(f.name).unlink()
+
+
+@pytest.fixture
+def empty_project():
+    with tempfile.TemporaryDirectory() as temp_dir:
+        yield Path(temp_dir)
+
+@pytest.fixture
+def project_with_syntax_error():
+    with tempfile.TemporaryDirectory() as temp_dir:
+        project_path = Path(temp_dir)
+        
+        valid_py = project_path / "valid.py"
+        valid_py.write_text("def valid_function():\n    return True\n")
+        
+        invalid_py = project_path / "invalid.py"
+        invalid_py.write_text("def invalid_function(\n    # Missing closing parenthesis\n    return False\n")
+        
+        yield project_path
+
+@pytest.fixture(autouse=True)
+def cleanup_temp_files():
+    """auto cleanup any temporary files after each test"""
+    yield
+
+pytest_plugins = []
+
+def pytest_configure(config):
+    config.addinivalue_line(
+        "markers", "integration: mark test as an integration test"
+    )
+    config.addinivalue_line(
+        "markers", "unit: mark test as a unit test"
+    )
+    config.addinivalue_line(
+        "markers", "slow: mark test as slow running"
+    )
+    config.addinivalue_line(
+        "markers", "cli: mark test as CLI interface test"
+    )
+
+@pytest.fixture
+def mock_git_repo():
+    with tempfile.TemporaryDirectory() as temp_dir:
+        repo_path = Path(temp_dir)
+        
+        try:
+            import subprocess
+            subprocess.run(["git", "init"], cwd=repo_path, check=True, 
+                          capture_output=True)
+            subprocess.run(["git", "config", "user.email", "test@example.com"], 
+                          cwd=repo_path, check=True)
+            subprocess.run(["git", "config", "user.name", "Test User"], 
+                          cwd=repo_path, check=True)
+            
+            test_file = repo_path / "test.py"
+            test_file.write_text("def test(): pass\n")
+            subprocess.run(["git", "add", "."], cwd=repo_path, check=True)
+            subprocess.run(["git", "commit", "-m", "Initial commit"], 
+                          cwd=repo_path, check=True)
+        except (subprocess.CalledProcessError, FileNotFoundError):
+            pass
+            
+        yield repo_path