skylos 1.2.1__tar.gz → 2.0.0__tar.gz

{skylos-1.2.1 → skylos-2.0.0}/PKG-INFO

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

{skylos-1.2.1 → skylos-2.0.0}/README.md

@@ -11,15 +11,23 @@
 
 > A static analysis tool for Python codebases written in Python (formerly was written in Rust but we ditched that) that detects unreachable functions and unused imports, aka dead code. Faster and better results than many alternatives like Flake8 and Pylint, and finding more dead code than Vulture in our tests with comparable speed.
 
+<div align="center">
+   <img src="assets/FE_SS.png" alt="FE" width="800">
+</div>
+
+
 ## Table of Contents
 
 - [Features](#features)
 - [Benchmark](#benchmark-you-can-find-this-benchmark-test-in-test-folder)
 - [Installation](#installation)
 - [Quick Start](#quick-start)
+- [Web Interface](#web-interface)
 - [Understanding Confidence Levels](#understanding-confidence-levels)
 - [Test File Detection](#test-file-detection)
 - [Folder Management](#folder-management)
+- [Ignoring Pragmas](#ignoring-pragmas)
+- [Including & Excluding Files](#including--excluding-files)
 - [CLI Options](#cli-options)
 - [Example Output](#example-output)
 - [Interactive Mode](#interactive-mode)
@@ -41,6 +49,7 @@
 * **Unused Classes**: Detects classes that are not instantiated or inherited
 * **Unused Imports**: Identifies imports that are not used
 * **Folder Management**: Inclusion/exclusion of directories 
+* **Ignore Pragmas**: Skip lines tagged with `# pragma: no skylos`, `# pragma: no cover`, or `# noqa`
 
 ## Benchmark (You can find this benchmark test in `test` folder)
 
@@ -87,6 +96,9 @@ pip install .
 # Analyze a project
 skylos /path/to/your/project
 
+# To launch the front end
+skylos run
+
 # Interactive mode - select items to remove
 skylos --interactive /path/to/your/project 
 
@@ -100,6 +112,17 @@ skylos --json /path/to/your/project
 skylos path/to/your/file --confidence 20 ## or whatever value u wanna set
 ```
 
+## Web Interface
+
+Skylos includes a modern web dashboard for interactive analysis:
+
+```bash
+# Start web interface
+skylos run
+
+# Opens browser at http://localhost:5090
+```
+
 ## Understanding Confidence Levels
 
 Skylos uses a confidence-based system to try to handle Python's dynamic nature and web frameworks.
@@ -162,6 +185,18 @@ When Skylos detects a test file, it by default, will apply a confidence penalty
 /project/test_data.py 
 ```
 
+## Ignoring Pragmas
+
+To ignore any warning, indicate `# pragma: no skylos` **ON THE SAME LINE** as the function/class you want to ignore
+
+Example
+
+```python
+    def with_logging(self, enabled: bool = True) -> "WebPath":     # pragma: no skylos
+        new_path = WebPath(self._url)
+        return new_path
+```
+
 ## Including & Excluding Files
 
 ### Default Exclusions

{skylos-1.2.1 → skylos-2.0.0}/pyproject.toml

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

{skylos-1.2.1 → skylos-2.0.0}/setup.py

@@ -2,10 +2,13 @@ from setuptools import setup, find_packages
 
 setup(
     name="skylos",
-    version="1.2.1",
+    version="2.0.0",
     packages=find_packages(),
     python_requires=">=3.9",
-    install_requires=["inquirer>=3.0.0"],
+    install_requires=[
+        "inquirer>=3.0.0",
+        "flask>=2.0.0",
+        "flask-cors>=3.0.0"],
     classifiers=[
         "Development Status :: 4 - Beta",
         "Intended Audience :: Developers",

{skylos-1.2.1 → skylos-2.0.0}/skylos/__init__.py

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

{skylos-1.2.1 → skylos-2.0.0}/skylos/analyzer.py

@@ -11,10 +11,6 @@ from skylos.test_aware import TestAwareVisitor
 import os
 import traceback
 from skylos.framework_aware import FrameworkAwareVisitor, detect_framework_usage
-import io
-import tokenize
-import re
-import warnings
 
 logging.basicConfig(level=logging.INFO,format='%(asctime)s - %(levelname)s - %(message)s')
 logger=logging.getLogger('Skylos')
@@ -34,33 +30,20 @@ def parse_exclude_folders(user_exclude_folders, use_defaults=True, include_folde
     
     return exclude_set
 
-IGNORE_PATTERNS = (
-    r"#\s*pragma:\s*no\s+skylos", ## our own pragma
-    r"#\s*pragma:\s*no\s+cover",
-    r"#\s*noqa(?:\b|:)", # flake8 style
-)
-
-def _collect_ignored_lines(source: str) -> set[int]:
-    ignores = set()
-    for tok in tokenize.generate_tokens(io.StringIO(source).readline):
-        if tok.type == tokenize.COMMENT:
-            if any(re.search(pat, tok.string, flags=re.I) for pat in IGNORE_PATTERNS):
-                ignores.add(tok.start[0])
-    return ignores
-
 class Skylos:
     def __init__(self):
         self.defs={}
         self.refs=[]
         self.dynamic=set()
         self.exports=defaultdict(set)
-        self.ignored_lines:set[int]=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)
+        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 _should_exclude_file(self, file_path, root_path, exclude_folders):
         if not exclude_folders:
@@ -111,9 +94,9 @@ class Skylos:
         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('_'):
-                d.is_exported = True
+        for name, definition in self.defs.items():
+            if definition.in_init and not definition.simple_name.startswith('_'):
+                definition.is_exported = True
         
         for mod, export_names in self.exports.items():
             for name in export_names:
@@ -137,8 +120,8 @@ class Skylos:
                         break
 
         simple_name_lookup = defaultdict(list)
-        for d in self.defs.values():
-            simple_name_lookup[d.simple_name].append(d)
+        for definition in self.defs.values():
+            simple_name_lookup[definition.simple_name].append(definition)
         
         for ref, _ in self.refs:
             if ref in self.defs:
@@ -151,8 +134,8 @@ class Skylos:
             
             simple = ref.split('.')[-1]
             matches = simple_name_lookup.get(simple, [])
-            for d in matches:
-                d.references += 1
+            for definition in matches:
+                definition.references += 1
  
         for module_name in self.dynamic:
             for def_name, def_obj in self.defs.items():
@@ -172,59 +155,58 @@ class Skylos:
         return []
     
     def _apply_penalties(self, def_obj, visitor, framework):
-        c = 100
-        
+        confidence=100
         if def_obj.simple_name.startswith("_") and not def_obj.simple_name.startswith("__"):
-            c -= PENALTIES["private_name"] 
+            confidence -= PENALTIES["private_name"] 
         if def_obj.simple_name.startswith("__") and def_obj.simple_name.endswith("__"):
-            c -= PENALTIES["dunder_or_magic"]
+            confidence -= PENALTIES["dunder_or_magic"]
         if def_obj.type == "variable" and def_obj.simple_name == "_":
-            c -= PENALTIES["underscored_var"]
+            confidence -= PENALTIES["underscored_var"]
         if def_obj.in_init and def_obj.type in ("function", "class"):
-            c -= PENALTIES["in_init_file"]
+            confidence -= PENALTIES["in_init_file"]
         if def_obj.name.split(".")[0] in self.dynamic:
-            c -= PENALTIES["dynamic_module"]
+            confidence -= PENALTIES["dynamic_module"]
         if visitor.is_test_file or def_obj.line in visitor.test_decorated_lines:
-            c -= PENALTIES["test_related"]
+            confidence -= PENALTIES["test_related"]
         
         framework_confidence = detect_framework_usage(def_obj, visitor=framework)
         if framework_confidence is not None:
-            c = min(c, framework_confidence)
+            confidence = min(confidence, framework_confidence)
 
         if (def_obj.simple_name.startswith("__") and def_obj.simple_name.endswith("__")):
-            c = 0
+            confidence = 0
 
         if def_obj.type == "parameter":
             if def_obj.simple_name in ("self", "cls"):
-                c = 0
+                confidence = 0
             elif "." in def_obj.name:
                 method_name = def_obj.name.split(".")[-2]
                 if method_name.startswith("__") and method_name.endswith("__"):
-                    c = 0
+                    confidence = 0
         
         if visitor.is_test_file or def_obj.line in visitor.test_decorated_lines:
-            c = 0
+            confidence = 0
         
         if (def_obj.type == "import" and def_obj.name.startswith("__future__.") and
             def_obj.simple_name in ("annotations", "absolute_import", "division", 
                                 "print_function", "unicode_literals", "generator_stop")):
-            c = 0
+            confidence = 0
         
-        def_obj.confidence = max(c, 0)
+        def_obj.confidence = max(confidence, 0)
 
     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]
+        for definition in self.defs.values():
+            if definition.type in ("method", "function") and "." in definition.name:
+                cls = definition.name.rsplit(".", 1)[0]
                 if cls in self.defs and self.defs[cls].type == "class":
-                    class_methods[cls].append(d)
+                    class_methods[cls].append(definition)
         
         for cls, methods in class_methods.items():
             if self.defs[cls].references > 0:
-                for m in methods:
-                    if m.simple_name in AUTO_CALLED:  # __init__, __enter__, __exit__
-                        m.references += 1
+                for method in methods:
+                    if method.simple_name in AUTO_CALLED:
+                        method.references += 1
 
     def analyze(self, path, thr=60, exclude_folders=None):
         files, root = self._get_python_files(path, exclude_folders)
@@ -251,25 +233,11 @@ class Skylos:
         
         for file in files:
             mod = modmap[file]
+            defs, refs, dyn, exports, test_flags, framework_flags = proc_file(file, mod)
 
-            result = proc_file(file, mod)
-
-            if len(result) == 7: ##new
-                defs, refs, dyn, exports, test_flags, framework_flags, ignored = result
-                self.ignored_lines.update(ignored)
-            else: ##legacy
-                warnings.warn(
-                    "proc_file() now returns 7 values (added ignored_lines). "
-                    "The 6-value form is deprecated and will disappear.",
-                    DeprecationWarning,
-                    stacklevel=2,
-                )
-                defs, refs, dyn, exports, test_flags, framework_flags = result
-
-            # apply penalties while we still have the file-specific flags
-            for d in defs:
-                self._apply_penalties(d, test_flags, framework_flags) 
-                self.defs[d.name] = d
+            for definition in defs:
+                self._apply_penalties(definition, test_flags, framework_flags) 
+                self.defs[definition.name] = definition
 
             self.refs.extend(refs)
             self.dynamic.update(dyn)
@@ -282,11 +250,9 @@ class Skylos:
         thr = max(0, thr)
 
         unused = []
-        for d in self.defs.values():
-                if (d.references == 0 and not d.is_exported
-                    and d.confidence >= thr
-                    and d.line not in self.ignored_lines):
-                        unused.append(d.to_dict())
+        for definition in self.defs.values():
+                if definition.references == 0 and not definition.is_exported and definition.confidence > 0 and definition.confidence >= thr:
+                    unused.append(definition.to_dict())
 
         result = {
             "unused_functions": [], 
@@ -322,7 +288,6 @@ def proc_file(file_or_args, mod=None):
 
     try:
         source = Path(file).read_text(encoding="utf-8")
-        ignored = _collect_ignored_lines(source)   
         tree   = ast.parse(source)
 
         tv = TestAwareVisitor(filename=file)
@@ -334,7 +299,7 @@ def proc_file(file_or_args, mod=None):
         v  = Visitor(mod, file)
         v.visit(tree)
 
-        return v.defs, v.refs, v.dyn, v.exports, tv, fv, ignored
+        return v.defs, v.refs, v.dyn, v.exports, tv, fv
     except Exception as e:
         logger.error(f"{file}: {e}")
         if os.getenv("SKYLOS_DEBUG"):
@@ -342,55 +307,56 @@ def proc_file(file_or_args, mod=None):
         dummy_visitor = TestAwareVisitor(filename=file)
         dummy_framework_visitor = FrameworkAwareVisitor(filename=file)
 
-        return [], [], set(), set(), dummy_visitor, dummy_framework_visitor, set()
+        return [], [], set(), set(), dummy_visitor, dummy_framework_visitor
 
 def analyze(path,conf=60, exclude_folders=None):
     return Skylos().analyze(path,conf, exclude_folders)
 
-if __name__=="__main__":
+if __name__ == "__main__":
     if len(sys.argv)>1:
-        p=sys.argv[1];c=int(sys.argv[2])if len(sys.argv)>2 else 60
-        result = analyze(p,c)
+        p = sys.argv[1]
+        confidence = int(sys.argv[2]) if len(sys.argv) >2 else 60
+        result = analyze(p,confidence)
         
         data = json.loads(result)
-        print("\n🔍 Python Static Analysis Results")
+        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'])}")
+            print(f" * Unreachable functions: {len(data['unused_functions'])}")
         if data["unused_imports"]:
-            print(f"  • Unused imports: {len(data['unused_imports'])}")
+            print(f" * Unused imports: {len(data['unused_imports'])}")
         if data["unused_classes"]:
-            print(f"  • Unused classes: {len(data['unused_classes'])}")
+            print(f" * Unused classes: {len(data['unused_classes'])}")
         if data["unused_variables"]:
-            print(f"  • Unused variables: {len(data['unused_variables'])}")
+            print(f" * Unused variables: {len(data['unused_variables'])}")
         
         if data["unused_functions"]:
-            print("\n📦 Unreachable 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("\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("\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("\n - Unused Variables")
             print("==================")
             for i, var in enumerate(data["unused_variables"], 1):
                 print(f" {i}. {var['name']}")
@@ -403,7 +369,7 @@ if __name__=="__main__":
         print(f"```")
         
         print("\nNext steps:")
-        print("  • Use --interactive to select specific items to remove")
-        print("  • Use --dry-run to preview changes before applying them")
+        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]")