skylos 1.1.12__tar.gz → 1.2.1__tar.gz

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

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

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

@@ -3,6 +3,7 @@
 ![License: Apache 2.0](https://img.shields.io/badge/License-Apache%202.0-blue.svg)
 ![100% Local](https://img.shields.io/badge/privacy-100%25%20local-brightgreen)
 ![PyPI version](https://img.shields.io/pypi/v/skylos)
+![Security Policy](https://img.shields.io/badge/security-policy-brightgreen)
 
 <div align="center">
    <img src="assets/SKYLOS.png" alt="Skylos Logo" width="200">
@@ -10,12 +11,36 @@
 
 > 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.
 
+## Table of Contents
+
+- [Features](#features)
+- [Benchmark](#benchmark-you-can-find-this-benchmark-test-in-test-folder)
+- [Installation](#installation)
+- [Quick Start](#quick-start)
+- [Understanding Confidence Levels](#understanding-confidence-levels)
+- [Test File Detection](#test-file-detection)
+- [Folder Management](#folder-management)
+- [CLI Options](#cli-options)
+- [Example Output](#example-output)
+- [Interactive Mode](#interactive-mode)
+- [Development](#development)
+- [FAQ](#faq)
+- [Limitations](#limitations)
+- [Troubleshooting](#troubleshooting)
+- [Contributing](#contributing)
+- [Roadmap](#roadmap)
+- [License](#license)
+- [Contact](#contact)
+
 ## Features
 
-* Unused Functions & Methods: Finds functions and methods that are never called
-* Unused Classes: Detects classes that are never instantiated or inherited
-* Unused Imports: Identifies imports that serve no purpose
-* Cross-Module Tracking: Analyzes usage patterns across your entire codebase
+* **Framework-Aware Detection**: Attempt at handling Flask, Django, FastAPI routes and decorators  
+* **Test File Exclusion**: Auto excludes test files (you can include it back if you want)
+* **Interactive Cleanup**: Select specific items to remove from CLI
+* **Unused Functions & Methods**: Finds functions and methods that not called
+* **Unused Classes**: Detects classes that are not instantiated or inherited
+* **Unused Imports**: Identifies imports that are not used
+* **Folder Management**: Inclusion/exclusion of directories 
 
 ## Benchmark (You can find this benchmark test in `test` folder)
 
@@ -70,9 +95,74 @@ skylos --interactive --dry-run /path/to/your/project
 
 # Output to JSON
 skylos --json /path/to/your/project 
+
+# With confidence
+skylos path/to/your/file --confidence 20 ## or whatever value u wanna set
+```
+
+## Understanding Confidence Levels
+
+Skylos uses a confidence-based system to try to handle Python's dynamic nature and web frameworks.
+
+### How Confidence Works
+
+- **Confidence 100**: 100% unused (default imports, obvious dead functions)
+- **Confidence 60**: Default value - conservative detection 
+- **Confidence 40**: Framework helpers, functions in web app files
+- **Confidence 20**: Framework routes, decorated functions
+- **Confidence 0**: Show everything
+
+### Framework Detection
+
+When Skylos detects web framework imports (Flask, Django, FastAPI), it applies different confidence levels:
+
+```bash
+# only obvious dead codes
+skylos app.py --confidence 60  # THIS IS THE DEFAULT
+
+# include unused helpers in framework files  
+skylos app.py --confidence 30
+
+# include potentially unused routes
+skylos app.py --confidence 20
+
+# everything.. shows how all potential dead code
+skylos app.py --confidence 0
 ```
 
-## **NEW** Folder Management
+## Test File Detection
+
+Skylos automatically excludes test files from analysis because test code patterns often appear as "dead code" but are actually called by test frameworks. Should you need to include them in your test, just refer to the [Folder Management](#folder-management)  
+
+### What Gets Detected as Test Files
+
+**File paths containing:**
+- `/test/` or `/tests/` directories
+- Files ending with `_test.py`
+
+**Test imports:**
+- `pytest`, `unittest`, `nose`, `mock`, `responses`
+
+**Test decorators:**  
+- `@pytest.fixture`, `@pytest.mark.*`
+- `@patch`, `@mock.*`
+
+### Test File Behavior
+
+When Skylos detects a test file, it by default, will apply a confidence penalty of 100, which will essentially filter out all dead code detection
+
+```bash
+# This will show 0 dead code because its treated as test file
+/project/tests/test_user.py
+/project/test/helper.py  
+/project/utils_test.py
+
+# The files will be analyzed normally. Note that it doesn't end with _test.py
+/project/user.py
+/project/test_data.py 
+```
+
+## Including & Excluding Files
 
 ### Default Exclusions
 By default, Skylos excludes common folders: `__pycache__`, `.git`, `.pytest_cache`, `.mypy_cache`, `.tox`, `htmlcov`, `.coverage`, `build`, `dist`, `*.egg-info`, `venv`, `.venv`
@@ -113,6 +203,7 @@ Options:
   --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
+  -c, --confidence LEVEL       Confidence threshold (0-100). Lower values will show more items.
 ```
 
 ## Example Output
@@ -204,6 +295,12 @@ A: No. Always review results manually, especially for framework code, APIs, and
 **Q: Why did Ruff underperform?**
 A: Like all other tools, Ruff is focused on detecting specific, surface-level issues. Tools like Vulture and Skylos are built SPECIFICALLY for dead code detection. It is NOT a specialized dead code detector. If your goal is dead code, then ruff is the wrong tool. It is a good tool but it's like using a wrench to hammer a nail. Good tool, wrong purpose. 
 
+**Q: Why doesn't Skylos detect my unused Flask routes?**
+A: Web framework routes are given low confidence (20) because they might be called by external HTTP requests. Use `--confidence 20` to see them. We acknowledge there are current limitations to this approach so use it sparingly.
+
+**Q: What confidence level should I use?**
+A: Start with 60 (default) for safe cleanup. Use 30 for framework applications. Use 20 for more comprehensive auditing.
+
 ## Limitations
 
 - **Dynamic code**: `getattr()`, `globals()`, runtime imports are hard to detect
@@ -211,7 +308,7 @@ A: Like all other tools, Ruff is focused on detecting specific, surface-level is
 - **Test data**: Limited scenarios, your mileage may vary
 - **False positives**: Always manually review before deleting code
 
-If we can detect 100% of all dead code in any structure, we wouldn't be sitting here. But we definitely tried our best
+This is a STATIC code analyzer. If we can detect 100% of all dead code in any structure and framework, we wouldn't be sitting here. But we definitely tried our best.
 
 ## Troubleshooting
 
@@ -242,7 +339,6 @@ We welcome contributions! Please read our [Contributing Guidelines](CONTRIBUTING
 5. Open a Pull Request
 
 ## Roadmap
-- [ ] Add a production flag, to include dead codes that are used in test but not in the actual execution 
 - [x] Expand our test cases
 - [ ] Configuration file support 
 - [ ] Git hooks integration

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

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

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

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

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

@@ -1,13 +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 (
-    AUTO_CALLED, TEST_METHOD_PATTERN, MAGIC_METHODS,
-    TEST_LIFECYCLE_METHODS, TEST_IMPORT_PATTERNS, TEST_DECORATORS,
-    DEFAULT_EXCLUDE_FOLDERS
-)
+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
+import io
+import tokenize
+import re
+import warnings
 
 logging.basicConfig(level=logging.INFO,format='%(asctime)s - %(levelname)s - %(message)s')
 logger=logging.getLogger('Skylos')
@@ -27,12 +34,27 @@ 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)
@@ -131,6 +153,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:
@@ -143,128 +171,62 @@ class Skylos:
         
         return []
     
-    def _has_test_imports(self, file_path):
-        try:
-            with open(file_path, 'r', encoding='utf-8') as f:
-                content = f.read()
-                
-            for test_import in TEST_IMPORT_PATTERNS:
-                if f"import {test_import}" in content or f"from {test_import}" in content:
-                    return True
-                    
-            return False
-        except:
-            return False
-    
-    def _is_test_file(self, file_path):
-        """check if file locs indicates its a test file"""
-        file_str = str(file_path).lower()
-        
-        if (file_str.endswith("test.py") or 
-            file_str.endswith("_test.py") or 
-            "test_" in file_str or
-            "/test/" in file_str or
-            "/tests/" in file_str or
-            "\\test\\" in file_str or
-            "\\tests\\" in file_str):
-            return True
-            
-        return False
+    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)
 
-    def _has_test_decorators(self, file_path):
-        """Check if file uses test-related decorators"""
-        try:
-            with open(file_path, 'r', encoding='utf-8') as f:
-                content = f.read()
-                
-            for decorator in TEST_DECORATORS:
-                if f"@{decorator}" in content:
-                    return True
-                    
-            return False
-        except:
-            return False
-        
-    def _is_test_related(self, definition):
+        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
         
-        if "." in definition.name:
-            class_name = definition.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")):
-                return True
-        
-        if (definition.type == "method" and 
-            (TEST_METHOD_PATTERN.match(definition.simple_name) or
-             definition.simple_name in TEST_LIFECYCLE_METHODS)):
-            return True
-        
-        # NOT for imports, variables, parameters
-        if definition.type in ("function", "method", "class"):
-            if self._is_test_file(definition.filename):
-                return True
-                
-            if self._has_test_imports(definition.filename):
-                return True
-                
-            ## check decorators -- test related
-            if self._has_test_decorators(definition.filename):
-                return True
-            
-        return False
-                    
+        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 (d.type == "import" and d.name.startswith("__future__.") and
-                d.simple_name in ("annotations", "absolute_import", "division", 
-                                "print_function", "unicode_literals", "generator_stop")):
-                d.confidence = 0
-
-            if (d.simple_name.startswith("_") and 
-                not d.simple_name.startswith("__") and  
-                d.simple_name != "_"):
-                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 self._is_test_related(d):
-                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:
@@ -289,25 +251,43 @@ class Skylos:
         
         for file in files:
             mod = modmap[file]
-            defs, refs, dyn, exports = proc_file(file, mod)
-            
-            for d in defs: 
+
+            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
+
             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 >= thr
+                    and d.line not in self.ignored_lines):
+                        unused.append(d.to_dict())
+
         result = {
             "unused_functions": [], 
             "unused_imports": [], 
@@ -341,13 +321,28 @@ 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")
+        ignored = _collect_ignored_lines(source)   
+        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, ignored
     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, set()
 
 def analyze(path,conf=60, exclude_folders=None):
     return Skylos().analyze(path,conf, exclude_folders)

{skylos-1.1.12 → skylos-1.2.1}/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-1.2.1/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)))