skylos 2.1.1__py3-none-any.whl → 2.2.2__py3-none-any.whl

skylos/__init__.py

@@ -1,8 +1,10 @@
-from skylos.analyzer import analyze
+__version__ = "2.2.2"
 
-__version__ = "2.1.1"
+def analyze(*args, **kwargs):
+    from .analyzer import analyze as _analyze
+    return _analyze(*args, **kwargs)
 
 def debug_test():
     return "debug-ok"
 
-__all__ = ["analyze", "debug_test", "__version__"]
+__all__ = ["analyze", "debug_test", "__version__"]

skylos/analyzer.py

@@ -7,10 +7,11 @@ from pathlib import Path
 from collections import defaultdict
 from skylos.visitor import Visitor
 from skylos.constants import ( PENALTIES, AUTO_CALLED )
-from skylos.test_aware import TestAwareVisitor
+from skylos.visitors.test_aware import TestAwareVisitor
+from skylos.rules.secrets import scan_ctx as _secrets_scan_ctx
 import os
 import traceback
-from skylos.framework_aware import FrameworkAwareVisitor, detect_framework_usage
+from skylos.visitors.framework_aware import FrameworkAwareVisitor, detect_framework_usage
 
 logging.basicConfig(level=logging.INFO,format='%(asctime)s - %(levelname)s - %(message)s')
 logger=logging.getLogger('Skylos')
@@ -155,18 +156,40 @@ class Skylos:
     
     def _apply_penalties(self, def_obj, visitor, framework):
         confidence=100
+
+        if getattr(visitor, "ignore_lines", None) and def_obj.line in visitor.ignore_lines:
+            def_obj.confidence = 0
+            return
+
+        if def_obj.type == "variable" and def_obj.simple_name == "_":
+            def_obj.confidence = 0
+            return
+
         if def_obj.simple_name.startswith("_") and not def_obj.simple_name.startswith("__"):
             confidence -= PENALTIES["private_name"] 
+
         if def_obj.simple_name.startswith("__") and def_obj.simple_name.endswith("__"):
             confidence -= PENALTIES["dunder_or_magic"]
-        if def_obj.type == "variable" and def_obj.simple_name.isupper():
-            confidence = 0
+
         if def_obj.in_init and def_obj.type in ("function", "class"):
             confidence -= PENALTIES["in_init_file"]
+            
         if def_obj.name.split(".")[0] in self.dynamic:
             confidence -= PENALTIES["dynamic_module"]
+
         if visitor.is_test_file or def_obj.line in visitor.test_decorated_lines:
             confidence -= PENALTIES["test_related"]
+
+        if def_obj.type == "variable" and getattr(framework, "dataclass_fields", None):
+            if def_obj.name in framework.dataclass_fields:
+                def_obj.confidence = 0
+                return
+            
+        if def_obj.type == "variable":
+            fr = getattr(framework, "first_read_lineno", {}).get(def_obj.name)
+            if fr is not None and fr >= def_obj.line:
+                def_obj.confidence = 0
+                return
         
         framework_confidence = detect_framework_usage(def_obj, visitor=framework)
         if framework_confidence is not None:
@@ -215,7 +238,7 @@ class Skylos:
                     if method.simple_name == "format" and cls.endswith("Formatter"):
                         method.references += 1
 
-    def analyze(self, path, thr=60, exclude_folders=None):
+    def analyze(self, path, thr=60, exclude_folders= None, enable_secrets = False):
         files, root = self._get_python_files(path, exclude_folders)
         
         if not files:
@@ -238,6 +261,7 @@ class Skylos:
         for f in files:
             modmap[f] = self._module(root, f)
         
+        all_secrets = []
         for file in files:
             mod = modmap[file]
             defs, refs, dyn, exports, test_flags, framework_flags = proc_file(file, mod)
@@ -250,6 +274,16 @@ class Skylos:
             self.dynamic.update(dyn)
             self.exports[mod].update(exports)
 
+            if enable_secrets and _secrets_scan_ctx is not None:
+                try:
+                    src_lines = Path(file).read_text(encoding="utf-8", errors="ignore").splitlines(True)
+                    ctx = {"relpath": str(file), "lines": src_lines, "tree": None}
+                    findings = list(_secrets_scan_ctx(ctx))
+                    if findings:
+                        all_secrets.extend(findings)
+                except Exception:
+                    pass
+
         self._mark_refs()
         self._apply_heuristics() 
         self._mark_exports()
@@ -262,7 +296,7 @@ class Skylos:
         for d in sorted(self.defs.values(), key=def_sort_key):
             if shown >= 50:
                 break
-            print(f" {d.type:<8} refs={d.references:<2} conf={d.confidence:<3} exported={d.is_exported} line={d.line:<4} {d.name}")
+            print(f" type={d.type} refs={d.references} conf={d.confidence} exported={d.is_exported} line={d.line} name={d.name}")
             shown += 1
 
         unused = []
@@ -281,6 +315,9 @@ class Skylos:
                 "excluded_folders": exclude_folders or [],
             }
         }
+
+        if enable_secrets and all_secrets:
+            result["secrets"] = all_secrets
         
         for u in unused:
             if u["type"] in ("function", "method"):
@@ -304,10 +341,13 @@ def proc_file(file_or_args, mod=None):
 
     try:
         source = Path(file).read_text(encoding="utf-8")
-        tree   = ast.parse(source)
+        ignore_lines = {i for i, line in enumerate(source.splitlines(), start=1)
+                        if "pragma: no skylos" in line}
+        tree = ast.parse(source)
 
         tv = TestAwareVisitor(filename=file)
         tv.visit(tree)
+        tv.ignore_lines = ignore_lines
 
         fv = FrameworkAwareVisitor(filename=file)
         fv.visit(tree)
@@ -315,18 +355,23 @@ def proc_file(file_or_args, mod=None):
         v  = Visitor(mod, file)
         v.visit(tree)
 
+        fv.dataclass_fields = getattr(v, "dataclass_fields", set())
+        fv.first_read_lineno = getattr(v, "first_read_lineno", {})
+
         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"):
             logger.error(traceback.format_exc())
         dummy_visitor = TestAwareVisitor(filename=file)
+        dummy_visitor.ignore_lines = set()
         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)
+def analyze(path, conf=60, exclude_folders=None, enable_secrets=False):
+    return Skylos().analyze(path,conf, exclude_folders, enable_secrets)
 
 if __name__ == "__main__":
     if len(sys.argv)>1:

skylos/cli.py

@@ -8,8 +8,11 @@ from skylos.analyzer import analyze as run_analyze
 from skylos.codemods import (
     remove_unused_import_cst,
     remove_unused_function_cst,
+    comment_out_unused_import_cst,
+    comment_out_unused_function_cst, 
 )
 import pathlib
+import skylos
 
 try:
     import inquirer
@@ -79,6 +82,32 @@ def remove_unused_function(file_path, function_name, line_number):
     except Exception as e:
         logging.error(f"Failed to remove function {function_name} from {file_path}: {e}")
         return False
+    
+def comment_out_unused_import(file_path, import_name, line_number, marker="SKYLOS DEADCODE"):
+    path = pathlib.Path(file_path)
+    try:
+        src = path.read_text(encoding="utf-8")
+        new_code, changed = comment_out_unused_import_cst(src, import_name, line_number, marker=marker)
+        if not changed:
+            return False
+        path.write_text(new_code, encoding="utf-8")
+        return True
+    except Exception as e:
+        logging.error(f"Failed to comment out import {import_name} from {file_path}: {e}")
+        return False
+
+def comment_out_unused_function(file_path, function_name, line_number, marker="SKYLOS DEADCODE"):
+    path = pathlib.Path(file_path)
+    try:
+        src = path.read_text(encoding="utf-8")
+        new_code, changed = comment_out_unused_function_cst(src, function_name, line_number, marker=marker)
+        if not changed:
+            return False
+        path.write_text(new_code, encoding="utf-8")
+        return True
+    except Exception as e:
+        logging.error(f"Failed to comment out function {function_name} from {file_path}: {e}")
+        return False
 
 def interactive_selection(logger, unused_functions, unused_imports):
     if not INTERACTIVE_AVAILABLE:
@@ -109,7 +138,7 @@ def interactive_selection(logger, unused_functions, unused_imports):
             selected_functions = answers['functions']
     
     if unused_imports:
-        logger.info(f"\n{Colors.MAGENTA}{Colors.BOLD}Select unused imports to remove (hit spacebar to select):{Colors.RESET}")
+        logger.info(f"\n{Colors.MAGENTA}{Colors.BOLD}Select unused imports to act on (hit spacebar to select):{Colors.RESET}")
         
         import_choices = []
 
@@ -144,7 +173,7 @@ def print_badge(dead_code_count: int, logger):
         logger.info(f"![Dead Code: {dead_code_count}](https://img.shields.io/badge/Dead_Code-{dead_code_count}_detected-orange?logo=codacy&logoColor=red)")
         logger.info("```")
 
-def main() -> None:
+def main():
     if len(sys.argv) > 1 and sys.argv[1] == 'run':
         try:
             start_server()
@@ -158,11 +187,26 @@ def main() -> None:
         description="Detect unreachable functions and unused imports in a Python project"
     )
     parser.add_argument("path", help="Path to the Python project")
+
+    parser.add_argument(
+        "--version",
+        action="version", 
+        version=f"skylos {skylos.__version__}",
+        help="Show version and exit"
+    )
+    
     parser.add_argument(
         "--json",
         action="store_true",
         help="Output raw JSON",
     )
+
+    parser.add_argument(
+        "--comment-out",
+        action="store_true",
+        help="Comment out selected dead code instead of deleting it",
+    )
+
     parser.add_argument(
         "--output",
         "-o",
@@ -223,12 +267,15 @@ def main() -> None:
         help="List the default excluded folders and exit."
     )
 
+    parser.add_argument("--secrets", action="store_true",
+                   help="Scan for API keys. Off by default.")
+    
     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" {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")
@@ -257,7 +304,7 @@ def main() -> None:
             logger.info(f"{Colors.GREEN}📁 No folders excluded{Colors.RESET}")
 
     try:
-        result_json = run_analyze(args.path, conf=args.confidence, exclude_folders=list(final_exclude_folders))
+        result_json = run_analyze(args.path, conf=args.confidence, enable_secrets=bool(args.secrets), exclude_folders=list(final_exclude_folders))
         result = json.loads(result_json)
 
     except Exception as e:
@@ -273,6 +320,7 @@ def main() -> None:
     unused_parameters = result.get("unused_parameters", [])
     unused_variables = result.get("unused_variables", [])
     unused_classes = result.get("unused_classes", [])
+    secrets_findings = result.get("secrets", [])
     
     logger.info(f"{Colors.CYAN}{Colors.BOLD} Python Static Analysis Results{Colors.RESET}")
     logger.info(f"{Colors.CYAN}{'=' * 35}{Colors.RESET}")
@@ -283,49 +331,75 @@ 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}")
     logger.info(f" * Unused classes: {Colors.YELLOW}{len(unused_classes)}{Colors.RESET}")
+    if secrets_findings:
+        logger.info(f" * Secrets: {Colors.RED}{len(secrets_findings)}{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)
         
         if selected_functions or selected_imports:
-            logger.info(f"\n{Colors.BOLD}Selected items to remove:{Colors.RESET}")
+            logger.info(f"\n{Colors.BOLD}Selected items to process:{Colors.RESET}")
             
             if selected_functions:
-                logger.info(f"  Functions: {len(selected_functions)}")
+                logger.info(f" Functions: {len(selected_functions)}")
                 for func in selected_functions:
-                    logger.info(f"    - {func['name']} ({func['file']}:{func['line']})")
+                    logger.info(f"  - {func['name']} ({func['file']}: {func['line']})")
             
             if selected_imports:
-                logger.info(f"  Imports: {len(selected_imports)}")
+                logger.info(f" Imports: {len(selected_imports)}")
                 for imp in selected_imports:
-                    logger.info(f"    - {imp['name']} ({imp['file']}:{imp['line']})")
+                    logger.info(f"  - {imp['name']} ({imp['file']}: {imp['line']})")
             
             if not args.dry_run:
+                if args.comment_out:
+                    confirm_verb = "comment out"
+                else:
+                    confirm_verb = "remove"
+
                 questions = [
                     inquirer.Confirm('confirm',
-                                   message="Are you sure you want to remove these items?",
+                                   message="Are you sure you want to process these items?",
                                    default=False)
                 ]
                 answers = inquirer.prompt(questions)
                 
                 if answers and answers['confirm']:
-                    logger.info(f"\n{Colors.YELLOW}Removing selected items...{Colors.RESET}")
-                    
+                    action = "Commenting out" if args.comment_out else "Removing"
+                    logger.info(f"\n{Colors.YELLOW}{action} selected items...{Colors.RESET}")
+
+                    action_func = comment_out_unused_function if args.comment_out else remove_unused_function
+                    if args.comment_out:
+                        action_past = "Commented out"
+                        action_verb = "comment out"
+                    else:
+                        action_past = "Removed"
+                        action_verb = "remove"
+
                     for func in selected_functions:
-                        success = remove_unused_function(func['file'], func['name'], func['line'])
+                        success = action_func(func['file'], func['name'], func['line'])
+                        
                         if success:
-                            logger.info(f"  {Colors.GREEN} {Colors.RESET} Removed function: {func['name']}")
+                            logger.info(f"  {Colors.GREEN} ✓ {Colors.RESET} {action_past} function: {func['name']}")
                         else:
-                            logger.error(f"  {Colors.RED} x {Colors.RESET} Failed to remove: {func['name']}")
-                    
+                            logger.error(f"  {Colors.RED} x {Colors.RESET} Failed to {action_verb}: {func['name']}")
+                            
+                    import_func = comment_out_unused_import if args.comment_out else remove_unused_import
+                    if args.comment_out:
+                        action_past = "Commented out"
+                        action_verb = "comment out"
+                    else:
+                        action_past = "Removed"
+                        action_verb = "remove"
+
                     for imp in selected_imports:
-                        success = remove_unused_import(imp['file'], imp['name'], imp['line'])
+                        success = import_func(imp['file'], imp['name'], imp['line'])
+                        
                         if success:
-                            logger.info(f"  {Colors.GREEN} {Colors.RESET} Removed import: {imp['name']}")
+                            logger.info(f"  {Colors.GREEN} ✓ {Colors.RESET} {action_past} import: {imp['name']}")
                         else:
-                            logger.error(f"  {Colors.RED} x {Colors.RESET} Failed to remove: {imp['name']}")
-                    
+                            logger.error(f"  {Colors.RED} x {Colors.RESET} Failed to {action_verb}: {imp['name']}")
+                            
                     logger.info(f"\n{Colors.GREEN}Cleanup complete!{Colors.RESET}")
                 else:
                     logger.info(f"\n{Colors.YELLOW}Operation cancelled.{Colors.RESET}")
@@ -368,6 +442,8 @@ 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}")
+        else:
+            logger.info(f"\n{Colors.GREEN}✓ All variables are being used!{Colors.RESET}")
                 
         if unused_classes:
             logger.info(f"\n{Colors.YELLOW}{Colors.BOLD} - Unused Classes{Colors.RESET}")
@@ -375,9 +451,18 @@ def main() -> None:
             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}")
+            logger.info(f"\n{Colors.GREEN}✓ All classes are being used!{Colors.RESET}")
+
+        if secrets_findings:
+            logger.info(f"\n{Colors.RED}{Colors.BOLD} - Secrets{Colors.RESET}")
+            logger.info(f"{Colors.RED}{'=' * 9}{Colors.RESET}")
+            for i, s in enumerate(secrets_findings[:20], 1):
+                provider = s.get("provider", "generic")
+                where = f"{s.get('file','?')}:{s.get('line','?')}"
+                prev = s.get("preview", "****")
+                msg = s.get("message", "Secret detected")
+                logger.info(f"{Colors.GRAY}{i:2d}. {Colors.RESET}{msg} [{provider}] {Colors.GRAY}({where}){Colors.RESET} -> {prev}")
 
         dead_code_count = len(unused_functions) + len(unused_imports) + len(unused_variables) + len(unused_classes) + len(unused_parameters)
 

skylos/codemods.py

@@ -2,6 +2,155 @@ from __future__ import annotations
 import libcst as cst
 from libcst.metadata import PositionProvider
 
+class _CommentOutBlock(cst.CSTTransformer):
+
+    METADATA_DEPENDENCIES = (PositionProvider,)
+
+    def __init__(self, module_code, marker = "SKYLOS DEADCODE"):
+        self.module_code = module_code.splitlines(True)
+        self.marker = marker
+
+    def _comment_block(self, start_line, end_line):
+        lines = self.module_code[start_line - 1:end_line]
+        out = []
+        out.append(cst.EmptyLine(comment=cst.Comment(f"# {self.marker} START (lines {start_line}-{end_line})")))
+        for raw in lines:
+            out.append(cst.EmptyLine(comment=cst.Comment("# " + raw.rstrip("\n"))))
+        out.append(cst.EmptyLine(comment=cst.Comment(f"# {self.marker} END")))
+        return out
+
+class _CommentOutFunctionAtLine(_CommentOutBlock):
+    def __init__(self, func_name, target_line, module_code, marker):
+        super().__init__(module_code, marker)
+        self.func_name = func_name
+        self.target_line = target_line
+        self.changed = False
+
+    def _is_target(self, node: cst.CSTNode):
+        pos = self.get_metadata(PositionProvider, node, None)
+        return pos and pos.start.line == self.target_line
+
+    def leave_FunctionDef(self, orig: cst.FunctionDef, updated: cst.FunctionDef):
+        if self._is_target(orig) and (orig.name.value == self.func_name):
+            self.changed = True
+            pos = self.get_metadata(PositionProvider, orig)
+            return cst.FlattenSentinel(self._comment_block(pos.start.line, pos.end.line))
+        return updated
+
+    def leave_AsyncFunctionDef(self, orig: cst.AsyncFunctionDef, updated: cst.AsyncFunctionDef):
+        if self._is_target(orig) and (orig.name.value == self.func_name):
+            self.changed = True
+            pos = self.get_metadata(PositionProvider, orig)
+            return cst.FlattenSentinel(self._comment_block(pos.start.line, pos.end.line))
+        return updated
+
+class _CommentOutImportAtLine(_CommentOutBlock):
+
+    def __init__(self, target_name, target_line, module_code, marker):
+        super().__init__(module_code, marker)
+        self.target_name = target_name
+        self.target_line = target_line
+        self.changed = False
+
+    def _is_target_line(self, node: cst.CSTNode):
+        pos = self.get_metadata(PositionProvider, node, None)
+        return bool(pos and (pos.start.line <= self.target_line <= pos.end.line))
+
+    def _render_single_alias_text(self, head, alias: cst.ImportAlias, is_from):
+        if is_from:
+            alias_txt = alias.name.code
+            if alias.asname:
+                alias_txt += f" as {alias.asname.name.value}"
+            return f"from {head} import {alias_txt}"
+        else:
+            alias_txt = alias.name.code
+            if alias.asname:
+                alias_txt += f" as {alias.asname.name.value}"
+            return f"import {alias_txt}"
+
+    def _split_aliases(self, aliases, head, is_from):
+        kept = []
+        removed_for_comment= []
+        for alias in list(aliases):
+            bound = _bound_name_for_import_alias(alias)
+            if bound == self.target_name:
+                self.changed = True
+                removed_for_comment.append(self._render_single_alias_text(head, alias, is_from))
+            else:
+                kept.append(alias)
+        return kept, removed_for_comment
+
+    def leave_Import(self, orig: cst.Import, updated: cst.Import):
+        if not self._is_target_line(orig):
+            return updated
+        
+        head = "" 
+        kept, removed = self._split_aliases(updated.names, head, is_from=False)
+        
+        if not removed:
+            return updated
+        
+        pos = self.get_metadata(PositionProvider, orig)
+        if not kept:
+            return cst.FlattenSentinel(self._comment_block(pos.start.line, pos.end.line))
+        
+        commented = []
+        for txt in removed:
+            comment = cst.Comment(f"# {self.marker}: {txt}")
+            commented.append(cst.EmptyLine(comment=comment))
+
+        kept_import = updated.with_changes(names=tuple(kept))
+        all_nodes = [kept_import] + commented
+        return cst.FlattenSentinel(all_nodes)
+
+    def leave_ImportFrom(self, orig: cst.ImportFrom, updated: cst.ImportFrom):
+        if not self._is_target_line(orig) or isinstance(updated.names, cst.ImportStar):
+            return updated
+        
+        if updated.relative:
+            dots = "." * len(updated.relative)
+        else:
+            dots = ""
+
+        if updated.module is not None:
+            modname = updated.module.code
+        else:
+            modname = ""
+
+        mod = f"{dots}{modname}"
+
+        kept, removed = self._split_aliases(list(updated.names), mod, is_from=True)
+        
+        if not removed:
+            return updated
+        pos = self.get_metadata(PositionProvider, orig)
+        
+        if not kept:
+            comment_block = self._comment_block(pos.start.line, pos.end.line)
+            return cst.FlattenSentinel(comment_block)
+
+        commented = []
+        for txt in removed:
+            comment = cst.Comment(f"# {self.marker}: {txt}")
+            commented.append(cst.EmptyLine(comment=comment))
+
+        updated_import = updated.with_changes(names=tuple(kept))
+        all_nodes = [updated_import] + commented
+
+        return cst.FlattenSentinel(all_nodes)
+
+def comment_out_unused_function_cst(code, func_name, line_number, marker = "SKYLOS DEADCODE"):
+    wrapper = cst.MetadataWrapper(cst.parse_module(code))
+    tx = _CommentOutFunctionAtLine(func_name, line_number, code, marker)
+    new_mod = wrapper.visit(tx)
+    return new_mod.code, tx.changed
+
+def comment_out_unused_import_cst(code, import_name, line_number, marker = "SKYLOS DEADCODE"):
+    wrapper = cst.MetadataWrapper(cst.parse_module(code))
+    tx = _CommentOutImportAtLine(import_name, line_number, code, marker)
+    new_mod = wrapper.visit(tx)
+    return new_mod.code, tx.changed
+
 def _bound_name_for_import_alias(alias: cst.ImportAlias):
     if alias.asname:
         return alias.asname.name.value
@@ -20,8 +169,8 @@ class _RemoveImportAtLine(cst.CSTTransformer):
 
     def _is_target_line(self, node: cst.CSTNode):
         pos = self.get_metadata(PositionProvider, node, None)
-        return bool(pos and pos.start.line == self.target_line)
-
+        return bool(pos and (pos.start.line <= self.target_line <= pos.end.line))
+    
     def _filter_aliases(self, aliases):
         kept = []
         for alias in aliases:
@@ -61,16 +210,16 @@ class _RemoveFunctionAtLine(cst.CSTTransformer):
 
     def _is_target(self, node: cst.CSTNode):
         pos = self.get_metadata(PositionProvider, node, None)
-        return bool(pos and pos.start.line == self.target_line)
+        return pos and pos.start.line == self.target_line
 
     def leave_FunctionDef(self, orig: cst.FunctionDef, updated: cst.FunctionDef):
-        if self._is_target(orig) and (orig.name.value in self.func_name):
+        if self._is_target(orig) and (orig.name.value == self.func_name):
             self.changed = True
             return cst.RemoveFromParent()
         return updated
 
     def leave_AsyncFunctionDef(self, orig: cst.AsyncFunctionDef, updated: cst.AsyncFunctionDef):
-        if self._is_target(orig) and (orig.name.value in self.func_name):
+        if self._is_target(orig) and (orig.name.value == self.func_name):
             self.changed = True
             return cst.RemoveFromParent()
 

skylos/constants.py

@@ -1,5 +1,4 @@
 import re
-from pathlib import Path
 
 PENALTIES = {
     "private_name": 80,   
@@ -35,10 +34,10 @@ DEFAULT_EXCLUDE_FOLDERS = {
     "htmlcov", ".coverage", "build", "dist", "*.egg-info", "venv", ".venv"
 }
 
-def is_test_path(p: Path | str) -> bool:
+def is_test_path(p):
     return bool(TEST_FILE_RE.search(str(p)))
 
-def is_framework_path(p: Path | str) -> bool:
+def is_framework_path(p):
     return bool(FRAMEWORK_FILE_RE.search(str(p)))
 
 def parse_exclude_folders(user_exclude_folders= None, use_defaults= True, include_folders= None):