skylos 1.0.11__tar.gz → 1.1.11__tar.gz

{skylos-1.0.11 → skylos-1.1.11}/PKG-INFO

@@ -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.0.11 → skylos-1.1.11}/README.md

@@ -72,6 +72,28 @@ skylos --interactive --dry-run /path/to/your/project
 skylos --json /path/to/your/project 
 ```
 
+## Folder Management
+
+### Default Exclusions
+By default, Skylos excludes common folders: `__pycache__`, `.git`, `.pytest_cache`, `.mypy_cache`, `.tox`, `htmlcov`, `.coverage`, `build`, `dist`, `*.egg-info`, `venv`, `.venv`
+
+### Folder Options
+```bash
+# List default excluded folders
+skylos --list-default-excludes
+
+# Exclude single folder (The example here will be venv)
+skylos /path/to/your/project --exclude-folder venv 
+
+# Exclude multiple folders
+skylos /path/to/your/project --exclude-folder venv --exclude-folder build
+
+# Force include normally excluded folders
+skylos /path/to/your/project --include-folder venv 
+
+# Scan everything (no exclusions)
+skylos path/to/your/project --no-default-excludes 
+
 ## CLI Options
 
 ```
@@ -81,12 +103,16 @@ Arguments:
   PATH  Path to the Python project to analyze
 
 Options:
-  -h, --help              Show this help message and exit
-  -j, --json             Output raw JSON instead of formatted text
-  -o, --output FILE      Write output to file instead of stdout
-  -v, --verbose          Enable verbose output
-  -i, --interactive      Interactively select items to remove
-  --dry-run              Show what would be removed without modifying files
+  -h, --help                    Show this help message and exit
+  -j, --json                   Output raw JSON instead of formatted text  
+  -o, --output FILE            Write output to file instead of stdout
+  -v, --verbose                Enable verbose output
+  -i, --interactive            Interactively select items to remove
+  --dry-run                    Show what would be removed without modifying files
+  --exclude-folder FOLDER      Exclude a folder from analysis (can be used multiple times)
+  --include-folder FOLDER      Force include a folder that would otherwise be excluded
+  --no-default-excludes        Don't exclude default folders (__pycache__, .git, venv, etc.)
+  --list-default-excludes      List the default excluded folders and
 ```
 
 ## Example Output
@@ -124,8 +150,6 @@ Next steps:
 
 The interactive mode lets you select specific functions and imports to remove:
 
-![Interactive Demo](docs/interactive-demo.gif)
-
 1. **Select items**: Use arrow keys and space to select/deselect
 2. **Confirm changes**: Review selected items before applying
 3. **Auto-cleanup**: Files are automatically updated
@@ -213,13 +237,11 @@ We welcome contributions! Please read our [Contributing Guidelines](CONTRIBUTING
 
 ## Roadmap
 - [ ] Add a production flag, to include dead codes that are used in test but not in the actual execution 
-- [ ] Expand our test cases
+- [x] Expand our test cases
 - [ ] Configuration file support 
-- [ ] Custom analysis rules
 - [ ] Git hooks integration
 - [ ] CI/CD integration examples
-- [ ] Web interface
-- [ ] Support for other languages
+~~- [] Support for other languages (unless I have contributors, this ain't possible)~~
 - [ ] Further optimization
 
 ## License

{skylos-1.0.11 → skylos-1.1.11}/pyproject.toml

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

{skylos-1.0.11 → skylos-1.1.11}/setup.py

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

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

@@ -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.0.11 → skylos-1.1.11}/skylos.egg-info/SOURCES.txt

@@ -13,18 +13,13 @@ skylos.egg-info/requires.txt
 skylos.egg-info/top_level.txt
 test/__init__.py
 test/compare_tools.py
+test/conftest.py
 test/diagnostics.py
+test/test_analyzer.py
+test/test_cli.py
+test/test_integration.py
 test/test_skylos.py
 test/test_visitor.py
-test/pykomodo/__init__.py
-test/pykomodo/command_line.py
-test/pykomodo/config.py
-test/pykomodo/core.py
-test/pykomodo/dashboard.py
-test/pykomodo/enhanced_chunker.py
-test/pykomodo/multi_dirs_chunker.py
-test/pykomodo/pykomodo_config.py
-test/pykomodo/token_chunker.py
 test/sample_repo/__init__.py
 test/sample_repo/app.py
 test/sample_repo/sample_repo/__init__.py

skylos-1.1.11/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