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

skylos/analyzer.py

@@ -1,31 +1,20 @@
 #!/usr/bin/env python3
-import ast,sys,json,logging,re
+import ast
+import sys
+import json
+import logging
 from pathlib import Path
 from collections import defaultdict
 from skylos.visitor import Visitor
+from skylos.constants import ( DEFAULT_EXCLUDE_FOLDERS, PENALTIES, AUTO_CALLED )
+from skylos.test_aware import TestAwareVisitor
+import os
+import traceback
+from skylos.framework_aware import FrameworkAwareVisitor, detect_framework_usage
 
 logging.basicConfig(level=logging.INFO,format='%(asctime)s - %(levelname)s - %(message)s')
 logger=logging.getLogger('Skylos')
 
-AUTO_CALLED={"__init__","__enter__","__exit__"}
-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()
     
@@ -145,6 +134,12 @@ class Skylos:
             matches = simple_name_lookup.get(simple, [])
             for d in matches:
                 d.references += 1
+ 
+        for module_name in self.dynamic:
+            for def_name, def_obj in self.defs.items():
+                if def_obj.name.startswith(f"{module_name}."):
+                    if def_obj.type in ("function", "method") and not def_obj.simple_name.startswith("_"):
+                        def_obj.references += 1
     
     def _get_base_classes(self, class_name):
         if class_name not in self.defs:
@@ -156,52 +151,63 @@ class Skylos:
             return class_def.base_classes
         
         return []
-            
+    
+    def _apply_penalties(self, def_obj, visitor, framework):
+        c = 100
+        
+        if def_obj.simple_name.startswith("_") and not def_obj.simple_name.startswith("__"):
+            c -= PENALTIES["private_name"] 
+        if def_obj.simple_name.startswith("__") and def_obj.simple_name.endswith("__"):
+            c -= PENALTIES["dunder_or_magic"]
+        if def_obj.type == "variable" and def_obj.simple_name == "_":
+            c -= PENALTIES["underscored_var"]
+        if def_obj.in_init and def_obj.type in ("function", "class"):
+            c -= PENALTIES["in_init_file"]
+        if def_obj.name.split(".")[0] in self.dynamic:
+            c -= PENALTIES["dynamic_module"]
+        if visitor.is_test_file or def_obj.line in visitor.test_decorated_lines:
+            c -= PENALTIES["test_related"]
+        
+        framework_confidence = detect_framework_usage(def_obj, visitor=framework)
+        if framework_confidence is not None:
+            c = min(c, framework_confidence)
+
+        if (def_obj.simple_name.startswith("__") and def_obj.simple_name.endswith("__")):
+            c = 0
+
+        if def_obj.type == "parameter":
+            if def_obj.simple_name in ("self", "cls"):
+                c = 0
+            elif "." in def_obj.name:
+                method_name = def_obj.name.split(".")[-2]
+                if method_name.startswith("__") and method_name.endswith("__"):
+                    c = 0
+        
+        if visitor.is_test_file or def_obj.line in visitor.test_decorated_lines:
+            c = 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
+        
+        def_obj.confidence = max(c, 0)
+
     def _apply_heuristics(self):
-        class_methods=defaultdict(list)
+        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":
+            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 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 d.type == "parameter" and d.simple_name in ("self", "cls"):
-                d.confidence = 0
-
-            if d.type != "parameter" and (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, 60)
-            
-            if d.type == "variable" and d.simple_name == "_":
-                d.confidence = 0
-            
-            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 (class_simple_name.startswith("Test") or 
-                    class_simple_name.endswith("Test") or 
-                    class_simple_name.endswith("TestCase")):
-                    d.confidence = 0
+                    if m.simple_name in AUTO_CALLED:  # __init__, __enter__, __exit__
+                        m.references += 1
 
     def analyze(self, path, thr=60, exclude_folders=None):
-        
         files, root = self._get_python_files(path, exclude_folders)
         
         if not files:
@@ -226,25 +232,28 @@ class Skylos:
         
         for file in files:
             mod = modmap[file]
-            defs, refs, dyn, exports = proc_file(file, mod)
-            
-            for d in defs: 
+            defs, refs, dyn, exports, test_flags, framework_flags = proc_file(file, mod)
+
+            # 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
+
             self.refs.extend(refs)
             self.dynamic.update(dyn)
             self.exports[mod].update(exports)
-        
+
         self._mark_refs()
-        self._apply_heuristics()
+        self._apply_heuristics() 
         self._mark_exports()
-                
+        
         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())
-        
+                if d.references == 0 and not d.is_exported and d.confidence > 0 and d.confidence >= thr:
+                    unused.append(d.to_dict())
+
         result = {
             "unused_functions": [], 
             "unused_imports": [], 
@@ -278,13 +287,27 @@ def proc_file(file_or_args, mod=None):
         file = file_or_args 
 
     try:
-        tree = ast.parse(Path(file).read_text(encoding="utf-8"))
-        v = Visitor(mod, file)
+        source = Path(file).read_text(encoding="utf-8")
+        tree   = ast.parse(source)
+
+        tv = TestAwareVisitor(filename=file)
+        tv.visit(tree)
+
+        fv = FrameworkAwareVisitor(filename=file)
+        fv.visit(tree)
+
+        v  = Visitor(mod, file)
         v.visit(tree)
-        return v.defs, v.refs, v.dyn, v.exports
+
+        return v.defs, v.refs, v.dyn, v.exports, tv, fv
     except Exception as e:
         logger.error(f"{file}: {e}")
-        return [], [], set(), set()
+        if os.getenv("SKYLOS_DEBUG"):
+            logger.error(traceback.format_exc())
+        dummy_visitor = TestAwareVisitor(filename=file)
+        dummy_framework_visitor = FrameworkAwareVisitor(filename=file)
+
+        return [], [], set(), set(), dummy_visitor, dummy_framework_visitor
 
 def analyze(path,conf=60, exclude_folders=None):
     return Skylos().analyze(path,conf, exclude_folders)

skylos/cli.py

@@ -218,6 +218,13 @@ def main() -> None:
         action="store_true",
         help="Enable verbose output"
     )
+    parser.add_argument(
+        "--confidence",
+        "-c",
+        type=int,
+        default=60,
+        help="Confidence threshold (0-100). Lower values include more items. Default: 60"
+    )
     parser.add_argument(
         "--interactive", "-i",
         action="store_true",
@@ -293,7 +300,7 @@ def main() -> None:
             logger.info(f"{Colors.GREEN}📁 No folders excluded{Colors.RESET}")
 
     try:
-        result_json = skylos.analyze(args.path, exclude_folders=list(final_exclude_folders))
+        result_json = skylos.analyze(args.path, conf=args.confidence, exclude_folders=list(final_exclude_folders))
         result = json.loads(result_json)
 
     except Exception as e:
@@ -308,6 +315,7 @@ def main() -> None:
     unused_imports = result.get("unused_imports", [])
     unused_parameters = result.get("unused_parameters", [])
     unused_variables = result.get("unused_variables", [])
+    unused_classes = result.get("unused_classes", [])
     
     logger.info(f"{Colors.CYAN}{Colors.BOLD}🔍 Python Static Analysis Results{Colors.RESET}")
     logger.info(f"{Colors.CYAN}{'=' * 35}{Colors.RESET}")
@@ -317,6 +325,7 @@ def main() -> None:
     logger.info(f"  • Unused imports: {Colors.YELLOW}{len(unused_imports)}{Colors.RESET}")
     logger.info(f"  • Unused parameters: {Colors.YELLOW}{len(unused_parameters)}{Colors.RESET}")
     logger.info(f"  • Unused variables: {Colors.YELLOW}{len(unused_variables)}{Colors.RESET}")
+    logger.info(f"  • Unused classes: {Colors.YELLOW}{len(unused_classes)}{Colors.RESET}")
 
     if args.interactive and (unused_functions or unused_imports):
         logger.info(f"\n{Colors.BOLD}Interactive Mode:{Colors.RESET}")
@@ -402,10 +411,19 @@ def main() -> None:
             for i, item in enumerate(unused_variables, 1):
                 logger.info(f"{Colors.GRAY}{i:2d}. {Colors.RESET}{Colors.YELLOW}{item['name']}{Colors.RESET}")
                 logger.info(f"    {Colors.GRAY}└─ {item['file']}:{item['line']}{Colors.RESET}")
+                
+        if unused_classes:
+            logger.info(f"\n{Colors.YELLOW}{Colors.BOLD}📚 Unused Classes{Colors.RESET}")
+            logger.info(f"{Colors.YELLOW}{'=' * 18}{Colors.RESET}")
+            for i, item in enumerate(unused_classes, 1):
+                logger.info(f"{Colors.GRAY}{i:2d}. {Colors.RESET}{Colors.YELLOW}{item['name']}{Colors.RESET}")
+                logger.info(f"    {Colors.GRAY}└─ {item['file']}:{item['line']}{Colors.RESET}")
+
         else:
             logger.info(f"\n{Colors.GREEN}✓ All variables are being used!{Colors.RESET}")
 
-        dead_code_count = len(unused_functions) + len(unused_imports)
+        dead_code_count = len(unused_functions) + len(unused_imports) + len(unused_variables) + len(unused_classes) + len(unused_parameters)
+
         print_badge(dead_code_count, logger)
 
         if unused_functions or unused_imports:

skylos/constants.py

@@ -0,0 +1,42 @@
+import re
+from pathlib import Path
+
+PENALTIES = {
+    "private_name":       80,   
+    "dunder_or_magic":    100, 
+    "underscored_var":    100, 
+    "in_init_file":       15, 
+    "dynamic_module":     40,
+    "test_related":       100,
+     "framework_magic":    40,
+}
+
+TEST_FILE_RE   = re.compile(r"(?:^|[/\\])tests?[/\\]|_test\.py$", re.I)
+TEST_IMPORT_RE = re.compile(r"^(pytest|unittest|nose|mock|responses)(\.|$)")
+TEST_DECOR_RE  = re.compile(r"""^(
+    pytest\.(fixture|mark) |
+    patch(\.|$) |
+    responses\.activate |
+    freeze_time
+)$""", re.X)
+
+AUTO_CALLED = {"__init__", "__enter__", "__exit__"}
+TEST_METHOD_PATTERN = re.compile(r"^test_\w+$")
+
+UNITTEST_LIFECYCLE_METHODS = {
+    'setUp', 'tearDown', 'setUpClass', 'tearDownClass', 
+    'setUpModule', 'tearDownModule'
+}
+
+FRAMEWORK_FILE_RE = re.compile(r"(?:views|handlers|endpoints|routes|api)\.py$", re.I)
+
+DEFAULT_EXCLUDE_FOLDERS = {
+    "__pycache__", ".git", ".pytest_cache", ".mypy_cache", ".tox",
+    "htmlcov", ".coverage", "build", "dist", "*.egg-info", "venv", ".venv"
+}
+
+def is_test_path(p: Path | str) -> bool:
+    return bool(TEST_FILE_RE.search(str(p)))
+
+def is_framework_path(p: Path | str) -> bool:
+    return bool(FRAMEWORK_FILE_RE.search(str(p)))

skylos/framework_aware.py

@@ -0,0 +1,158 @@
+import ast
+import fnmatch
+from pathlib import Path
+
+# decorator patterns for each of the more popular frameworks
+FRAMEWORK_DECORATORS = [
+    # flask
+    "@app.route", "@app.get", "@app.post", "@app.put", "@app.delete", 
+    "@app.patch", "@app.before_request", "@app.after_request",
+    "@app.errorhandler", "@app.teardown_*",
+    
+    # fastapi  
+    "@router.get", "@router.post", "@router.put", "@router.delete",
+    "@router.patch", "@router.head", "@router.options",
+    "@router.trace", "@router.websocket",
+    
+    # django
+    "@*_required", "@login_required", "@permission_required", 
+    "@user_passes_test", "@staff_member_required",
+    
+    # pydantic 
+    "@validator", "@field_validator", "@model_validator", "@root_validator",
+    
+    # celery patterns
+    "@task", "@shared_task", "@periodic_task", "@celery_task",
+    
+    # generic ones
+    "@route", "@get", "@post", "@put", "@delete", "@patch",
+    "@middleware", "@depends", "@inject"
+]
+
+FRAMEWORK_FUNCTIONS = [
+    # django view methods
+    "get", "post", "put", "patch", "delete", "head", "options", "trace",
+    "*_queryset", "get_queryset", "get_object", "get_context_data",
+    "*_form", "form_valid", "form_invalid", "get_form_*",
+    
+    # django model methods
+    "save", "delete", "clean", "full_clean", "*_delete", "*_save",
+    
+    # generic API endpoints
+    "create_*", "update_*", "delete_*", "list_*", "retrieve_*",
+    "handle_*", "process_*", "*_handler", "*_view"
+]
+
+FRAMEWORK_IMPORTS = {
+    'flask', 'fastapi', 'django', 'pydantic', 'celery', 'starlette', 
+    'sanic', 'tornado', 'pyramid', 'bottle', 'cherrypy', 'web2py',
+    'falcon', 'hug', 'responder', 'quart', 'hypercorn', 'uvicorn'
+}
+
+class FrameworkAwareVisitor:
+    
+    def __init__(self, filename=None):
+        self.is_framework_file = False
+        self.framework_decorated_lines = set()
+        self.detected_frameworks = set()
+        
+        if filename:
+            self._check_framework_imports_in_file(filename)
+
+    def visit(self, node):
+        method = 'visit_' + node.__class__.__name__
+        visitor = getattr(self, method, self.generic_visit)
+        return visitor(node)
+
+    def generic_visit(self, node):
+        for field, value in ast.iter_fields(node):
+            if isinstance(value, list):
+                for item in value:
+                    if isinstance(item, ast.AST):
+                        self.visit(item)
+            elif isinstance(value, ast.AST):
+                self.visit(value)
+
+    def visit_Import(self, node):
+        for alias in node.names:
+            if any(fw in alias.name.lower() for fw in FRAMEWORK_IMPORTS):
+                self.is_framework_file = True
+                self.detected_frameworks.add(alias.name.split('.')[0])
+        self.generic_visit(node)
+
+    def visit_ImportFrom(self, node):
+        if node.module:
+            module_name = node.module.split('.')[0].lower()
+            if module_name in FRAMEWORK_IMPORTS:
+                self.is_framework_file = True
+                self.detected_frameworks.add(module_name)
+        self.generic_visit(node)
+
+    def visit_FunctionDef(self, node):
+        for deco in node.decorator_list:
+            decorator_str = self._normalize_decorator(deco)
+            if self._matches_framework_pattern(decorator_str, FRAMEWORK_DECORATORS):
+                self.framework_decorated_lines.add(node.lineno)
+                self.is_framework_file = True
+        
+        if self._matches_framework_pattern(node.name, FRAMEWORK_FUNCTIONS):
+            if self.is_framework_file:  
+                self.framework_decorated_lines.add(node.lineno)
+        
+        self.generic_visit(node)
+
+    def visit_AsyncFunctionDef(self, node):
+        self.visit_FunctionDef(node)
+
+    def visit_ClassDef(self, node):
+        for base in node.bases:
+            if isinstance(base, ast.Name):
+                if any(pattern in base.id.lower() for pattern in ['view', 'viewset', 'api', 'handler']):
+                    if self.is_framework_file:
+                        self.framework_decorated_lines.add(node.lineno)
+        
+        self.generic_visit(node)
+
+    def _normalize_decorator(self, decorator_node):
+        if isinstance(decorator_node, ast.Name):
+            return f"@{decorator_node.id}"
+        elif isinstance(decorator_node, ast.Attribute):
+            if isinstance(decorator_node.value, ast.Name):
+                return f"@{decorator_node.value.id}.{decorator_node.attr}"
+            else:
+                return f"@{decorator_node.attr}"
+        elif isinstance(decorator_node, ast.Call):
+            return self._normalize_decorator(decorator_node.func)
+        return "@unknown"
+
+    def _matches_framework_pattern(self, text, patterns):
+        text_clean = text.lstrip('@')
+        return any(fnmatch.fnmatch(text_clean, pattern.lstrip('@')) for pattern in patterns)
+
+    def _check_framework_imports_in_file(self, filename):
+        try:
+            content = Path(filename).read_text(encoding='utf-8')
+            for framework in FRAMEWORK_IMPORTS:
+                if (f'import {framework}' in content or 
+                    f'from {framework}' in content):
+                    self.is_framework_file = True
+                    self.detected_frameworks.add(framework)
+                    break
+        except:
+            pass
+
+def detect_framework_usage(definition, decorator_nodes=None, visitor=None):
+    if not visitor:
+        return None
+    
+    # very low confidence - likely framework magic
+    if definition.line in visitor.framework_decorated_lines:
+        return 20  
+    
+    # framework file but no direct markers
+    if visitor.is_framework_file:
+        if (not definition.simple_name.startswith('_') and 
+            definition.type in ('function', 'method')):
+            return 40 
+    
+    return None

skylos/test_aware.py

@@ -0,0 +1,66 @@
+import ast
+from skylos.constants import TEST_IMPORT_RE, TEST_DECOR_RE, TEST_FILE_RE
+
+class TestAwareVisitor:
+    
+    def __init__(self, filename=None):
+        self.is_test_file = False
+        self.test_decorated_lines = set()
+        
+        # mark as test file based on the file path/name NOT imports
+        if filename and TEST_FILE_RE.search(str(filename)):
+            self.is_test_file = True
+
+    def visit(self, node):
+        method = 'visit_' + node.__class__.__name__
+        visitor = getattr(self, method, self.generic_visit)
+        return visitor(node)
+
+    def generic_visit(self, node):
+        for field, value in ast.iter_fields(node):
+            if isinstance(value, list):
+                for item in value:
+                    if isinstance(item, ast.AST):
+                        self.visit(item)
+            elif isinstance(value, ast.AST):
+                self.visit(value)
+
+    def visit_Import(self, node):
+  
+        if self.is_test_file: 
+            for alias in node.names:
+                if TEST_IMPORT_RE.match(alias.name):
+                    pass  
+        self.generic_visit(node)
+
+    def visit_ImportFrom(self, node):
+        if self.is_test_file:
+            if node.module and TEST_IMPORT_RE.match(node.module):
+                pass 
+        self.generic_visit(node)
+
+
+    def visit_FunctionDef(self, node):
+        if (node.name.startswith('test_') or 
+            node.name.endswith('_test') or
+            any(node.name.startswith(prefix) for prefix in ['setup', 'teardown']) or
+            node.name in ['setUp', 'tearDown', 'setUpClass', 'tearDownClass', 
+                        'setUpModule', 'tearDownModule']):
+            self.test_decorated_lines.add(node.lineno)
+        
+        for deco in node.decorator_list:
+            name = self._decorator_name(deco)
+            if name and (TEST_DECOR_RE.match(name) or 'pytest' in name or 'fixture' in name):
+                self.test_decorated_lines.add(node.lineno)
+        self.generic_visit(node)
+
+    def visit_AsyncFunctionDef(self, node):
+        self.visit_FunctionDef(node)
+
+    def _decorator_name(self, deco):
+        if isinstance(deco, ast.Name):
+            return deco.id
+        if isinstance(deco, ast.Attribute):
+            parent = self._decorator_name(deco.value)
+            return f"{parent}.{deco.attr}" if parent else deco.attr
+        return ""

skylos/visitor.py

@@ -1,6 +1,11 @@
 #!/usr/bin/env python3
 import ast
 from pathlib import Path
+import os 
+import re, logging, traceback
+DBG = bool(int(os.getenv("SKYLOS_DEBUG", "0")))
+log = logging.getLogger("Skylos")
+
 
 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"}
 DYNAMIC_PATTERNS={"getattr","globals","eval","exec"}
@@ -74,11 +79,23 @@ class Visitor(ast.NodeVisitor):
                 self.visit(node)
 
     def visit_string_annotation(self, annotation_str):
+        if not isinstance(annotation_str, str):
+            return
+
+        if DBG:
+            log.debug(f"[visitor] parsing string annotation {annotation_str!r} "
+                    f"in {self.filename}:{getattr(self, 'line', '?')}")
+
         try:
-            parsed = ast.parse(annotation_str, mode='eval')
+            parsed = ast.parse(annotation_str, mode="eval")
             self.visit(parsed.body)
-        except:
-            pass
+        except Exception:
+            if DBG:
+                log.debug("[visitor] inner-annotation parse failed:\n" +
+                        traceback.format_exc())
+            # keep going but dont swallow symbol names:
+            for tok in re.findall(r"[A-Za-z_][A-Za-z0-9_]*", annotation_str):
+                self.add_ref(tok)
 
     def visit_Import(self,node):
         for a in node.names:
@@ -250,6 +267,11 @@ class Visitor(ast.NodeVisitor):
                     if module_name != "self": 
                         qualified_name = f"{self.qual(module_name)}.{attr_name}"
                         self.add_ref(qualified_name)
+            
+            elif isinstance(node.args[0], ast.Name):
+                target_name = node.args[0].id
+                if target_name != "self":
+                    self.dyn.add(self.mod.split(".")[0] if self.mod else "")
         
         elif isinstance(node.func, ast.Name) and node.func.id == "globals":
             parent = getattr(node, 'parent', None)
@@ -259,6 +281,9 @@ 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.Name) and node.func.id in ("eval", "exec"):
+            self.dyn.add(self.mod.split(".")[0] if self.mod else "")
 
     def visit_Name(self,node):
         if isinstance(node.ctx,ast.Load):

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

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

skylos-1.2.0.dist-info/RECORD

@@ -0,0 +1,32 @@
+skylos/__init__.py,sha256=ZZWhq0TZ3G-yDi9inbYvMn8OBes-pqo1aYB5EivuxFI,152
+skylos/analyzer.py,sha256=MVO16T58bPpcISQKiHWtcQaeHG6r2awH6IuxHUmG56E,13858
+skylos/cli.py,sha256=6udZY4vLU6PFzVMkaiCLCRcLXgquyHdmf4rIOAPosWc,18266
+skylos/constants.py,sha256=F1kMjuTxfw2hJjd0SeOQcgex5WhHMUhXCzOlVmwuACs,1230
+skylos/framework_aware.py,sha256=p7BGoFnzkpaLJoE3M5qgyIeZvXx17tOkdyXgeqGKmqU,5804
+skylos/test_aware.py,sha256=cduaWMcFsuzIEQWAMFPC58xGk8NUU3SbUS0ChRPedv8,2372
+skylos/visitor.py,sha256=MnWyzs0b2JOD2Nj1Iu7ZIZHCr7fRC92PY1bsT8bdgXg,12796
+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=c8gbZuUls3N8xGGDXdPzsaoma6AFR2fIDqp9cNJlg7c,22104
+test/test_changes_analyzer.py,sha256=l1hspCFz-sF8gqOilJvntUDuGckwhYsVtzvSRB13ZWw,5085
+test/test_cli.py,sha256=rtdKzanDRJT_F92jKkCQFdhvlfwVJxfXKO8Hrbn-mIg,13180
+test/test_constants.py,sha256=pMuDy0UpC81zENMDCeK6Bqmm3BR_HHZQSlMG-9TgOm0,12602
+test/test_framework_aware.py,sha256=tJ7bnhiGeSdsAvrWaGJO5ovTrw9n9BBk6o1HCw15yDA,11693
+test/test_integration.py,sha256=bNKGUe-w0xEZEdnoQNHbssvKMGs9u9fmFQTOz1lX9_k,12398
+test/test_skylos.py,sha256=kz77STrS4k3Eez5RDYwGxOg2WH3e7zNZPUYEaTLbGTs,15608
+test/test_test_aware.py,sha256=VmbR_MQY0m941CAxxux8OxJHIr7l8crfWRouSeBMhIo,9390
+test/test_visitor.py,sha256=xAbGv-XaozKm_0WJJhr0hMb6mLaJcbPz57G9-SWkxFU,22764
+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.2.0.dist-info/METADATA,sha256=FqeObdsFPYrqrKzpBngriBQbKZXnOJUnqDKJQSn-N4k,224
+skylos-1.2.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+skylos-1.2.0.dist-info/entry_points.txt,sha256=zzRpN2ByznlQoLeuLolS_TFNYSQxUGBL1EXQsAd6bIA,43
+skylos-1.2.0.dist-info/top_level.txt,sha256=f8GA_7KwfaEopPMP8-EXDQXaqd4IbsOQPakZy01LkdQ,12
+skylos-1.2.0.dist-info/RECORD,,