is_generated_test_file= (any(tf.test_typein (TestType.HYPOTHESIS_TEST,TestType.CONCOLIC_COVERAGE_TEST)fortfintest_functions    )iftest_functionselseany(func.test_typein (TestType.HYPOTHESIS_TEST,TestType.CONCOLIC_COVERAGE_TEST)forfuncinfunctions    ))# For generated tests, use AST-based discovery since Jedi often failsifis_generated_test_fileandfunctions_to_optimize:logger.debug(f"Using AST-based discovery for generated test file:{test_file.name}")target_qualified_names= {func.qualified_name_with_modules_from_root(project_root_path)forfuncinfunctions_to_optimize    }ifnottest_functions:logger.debug("Jedi found no functions, building test_functions from collected functions")test_functions= {TestFunction(function_name=func.test_function,test_class=func.test_class,parameters=None,test_type=func.test_type,            )forfuncinfunctions        }ast_results=_discover_calls_via_ast(test_file,test_functions,target_qualified_names)forqualified_name,matchesinast_results.items():fortest_func,positioninmatches:iftest_func.parametersisnotNone:iftest_framework=="pytest":scope_test_function=f"{test_func.function_name}[{test_func.parameters}]"else:# unittestscope_test_function=f"{test_func.function_name}_{test_func.parameters}"else:scope_test_function=test_func.function_namefunction_to_test_map[qualified_name].add(FunctionCalledInTest(tests_in_file=TestsInFile(test_file=test_file,test_class=test_func.test_class,test_function=scope_test_function,test_type=test_func.test_type,                    ),position=position,                )            )tests_cache.insert_test(file_path=str(test_file),file_hash=file_hash,qualified_name_with_modules_from_root=qualified_name,

new_body.append(node)new_tree=ast.Module(body=new_body,type_ignores=[])returnast.unparse(new_tree)deffilter_hypothesis_tests_by_function_name(code:str,function_name:str)->str:"""Filter hypothesis tests to only include tests matching the function name.    Preserves all imports, module-level assignments, and only test functions    that contain the target function name.    Args:        code: The hypothesis test code to filter        function_name: The name of the function being tested    Returns:        Filtered code with only matching tests    """tree=ast.parse(code)classTestFunctionRemover(ast.NodeTransformer):defvisit_Module(self,node):# noqa: ANN001, ANN202# Filter body to keep imports, module-level assignments, and matching test functionsnew_body= []foriteminnode.body:ifisinstance(item, (ast.Import,ast.ImportFrom,ast.Assign)):# Keep all imports and module-level assignmentsnew_body.append(item)elifisinstance(item,ast.FunctionDef)anditem.name.startswith("test_")andfunction_nameinitem.name:# Only keep test functions that match the function namenew_body.append(item)node.body=new_bodyreturnnodemodified_tree=TestFunctionRemover().visit(tree)ast.fix_missing_locations(modified_tree)returnast.unparse(modified_tree)

def_compare_hypothesis_tests_semantic(original_hypothesis:list,candidate_hypothesis:list)->bool:"""Compare Hypothesis tests by test function, not by example count.    Hypothesis can generate different numbers of examples between runs due to:    - Timing differences    - Early stopping    - Shrinking behavior    - Performance differences    What matters is whether the test functions themselves pass or fail,    not how many examples Hypothesis generated.    """# Group by test function (excluding loop index and iteration_id from comparison)defget_test_key(test_result:FunctionTestInvocation)->tuple[str,str,str,str]:"""Get unique key for a Hypothesis test function."""return (test_result.id.test_module_path,test_result.id.test_class_name,test_result.id.test_function_name,test_result.id.function_getting_tested,        )# Group original results by test functionoriginal_by_func=defaultdict(list)forresultinoriginal_hypothesis:original_by_func[get_test_key(result)].append(result)# Group candidate results by test functioncandidate_by_func=defaultdict(list)forresultincandidate_hypothesis:candidate_by_func[get_test_key(result)].append(result)# Log summary statisticsorig_total_examples=sum(len(examples)forexamplesinoriginal_by_func.values())cand_total_examples=sum(len(examples)forexamplesincandidate_by_func.values())logger.debug(f"Hypothesis comparison: Original={len(original_by_func)} test functions ({orig_total_examples} examples), "f"Candidate={len(candidate_by_func)} test functions ({cand_total_examples} examples)"    )fortest_keyinoriginal_by_func:iftest_keynotincandidate_by_func:continue# Already handled aboveorig_examples=original_by_func[test_key]cand_examples=candidate_by_func[test_key]# Check if any original example failedorig_had_failure=any(notex.did_passforexinorig_examples)cand_had_failure=any(notex.did_passforexincand_examples)# If original had failures, candidate must also have failures (or be missing, already handled)# If original passed, candidate must pass (but can have different example counts)iforig_had_failure!=cand_had_failure:logger.debug(f"Hypothesis test function behavior mismatch:{test_key} "f"(original_failed={orig_had_failure}, candidate_failed={cand_had_failure})"            )returnFalsereturnTrue

 def get_qualified_function_path(file_path: Path, project_root_path: Path, qualified_name: str) -> str:-    module_path = file_path.relative_to(project_root_path).with_suffix("").as_posix().replace("/", ".")+    try:+        module_path = file_path.resolve().relative_to(project_root_path.resolve()).with_suffix("").as_posix().replace("/", ".")+    except ValueError:+        # Fall back to robust traversal if file is not directly under project_root_path+        module_path = module_name_from_file_path(file_path, project_root_path)     return f"{module_path}.{qualified_name}"

 def make_hypothesis_tests_deterministic(code: str) -> str:     """Add @settings(derandomize=True) decorator and constrain strategies to make Hypothesis tests deterministic."""     try:         tree = ast.parse(code)     except SyntaxError:         return code-...-        if settings_decorator:-            if not any(k.arg == "derandomize" for k in settings_decorator.keywords):-                settings_decorator.keywords.append(ast.keyword(arg="derandomize", value=ast.Constant(value=True)))-        else:-            node.decorator_list.append(-                ast.Call(-                    func=ast.Name(id="settings", ctx=ast.Load()),-                    args=[],-                    keywords=[ast.keyword(arg="derandomize", value=ast.Constant(value=True))],++    has_from_import_settings = any(+        isinstance(node, ast.ImportFrom)+        and node.module == "hypothesis"+        and any(alias.name == "settings" for alias in node.names)+        for node in tree.body+    )+    has_import_hypothesis = any(isinstance(node, ast.Import) and any(a.name == "hypothesis" for a in node.names) for node in tree.body)++    # Insert import if needed+    if not has_from_import_settings and not has_import_hypothesis:+        tree.body.insert(0, ast.parse("from hypothesis import settings").body[0])++    class StrategyConstrainer(ast.NodeTransformer):+        def visit_Call(self, node: ast.Call) -> ast.Call:+            self.generic_visit(node)+            if (+                isinstance(node.func, ast.Attribute)+                and isinstance(node.func.value, ast.Name)+                and node.func.value.id == "st"+            ):+                if node.func.attr == "floats" and not any(+                    k.arg in ["min_value", "max_value", "allow_nan", "allow_infinity"] for k in node.keywords+                ):+                    node.keywords.extend(+                        [+                            ast.keyword(arg="min_value", value=ast.UnaryOp(op=ast.USub(), operand=ast.Constant(value=1e6))),+                            ast.keyword(arg="max_value", value=ast.Constant(value=1e6)),+                            ast.keyword(arg="allow_nan", value=ast.Constant(value=False)),+                            ast.keyword(arg="allow_infinity", value=ast.Constant(value=False)),+                        ]+                    )+                elif node.func.attr == "integers" and not any(k.arg in ["min_value", "max_value"] for k in node.keywords):+                    node.keywords.extend(+                        [+                            ast.keyword(arg="min_value", value=ast.Constant(value=-10000)),+                            ast.keyword(arg="max_value", value=ast.Constant(value=10000)),+                        ]+                    )+            return node++    tree = StrategyConstrainer().visit(tree)+    ast.fix_missing_locations(tree)++    def settings_call() -> ast.expr:+        if has_from_import_settings or not has_import_hypothesis:+            return ast.Name(id="settings", ctx=ast.Load())+        # Use fully-qualified call if only `import hypothesis` exists+        return ast.Attribute(value=ast.Name(id="hypothesis", ctx=ast.Load()), attr="settings", ctx=ast.Load())++    for node in ast.walk(tree):+        if isinstance(node, ast.FunctionDef):+            settings_decorator = next(+                (d for d in node.decorator_list if isinstance(d, ast.Call) and (+                    (isinstance(d.func, ast.Name) and d.func.id == "settings") or+                    (isinstance(d.func, ast.Attribute) and isinstance(d.func.value, ast.Name) and d.func.value.id == "hypothesis" and d.func.attr == "settings")+                )),+                None,+            )+            if settings_decorator:+                if not any(k.arg == "derandomize" for k in settings_decorator.keywords):+                    settings_decorator.keywords.append(ast.keyword(arg="derandomize", value=ast.Constant(value=True)))+            else:+                node.decorator_list.append(+                    ast.Call(func=settings_call(), args=[], keywords=[ast.keyword(arg="derandomize", value=ast.Constant(value=True))])                 )-            )+    return ast.unparse(tree)+

 def _discover_calls_via_ast(     test_file: Path, test_functions: set[TestFunction], target_qualified_names: set[str] ) -> dict[str, list[tuple[TestFunction, CodePosition]]]:     try:         with test_file.open("r", encoding="utf-8") as f:             source = f.read()         tree = ast.parse(source, filename=str(test_file))     except (SyntaxError, FileNotFoundError) as e:         logger.debug(f"AST parsing failed for {test_file}: {e}")         return {}-...-        if parts[0] in import_map:-            resolved = f"{import_map[parts[0]]}.{parts[1]}" if len(parts) == 2 else import_map[parts[0]]-            if resolved in target_qualified_names:-                result[resolved].append((test_func, CodePosition(line_no=child.lineno, col_no=child.col_offset)))+    import_map: dict[str, str] = {}+    module_pkg: str | None = None+    # Attempt to infer current module path for relative imports+    try:+        rel = test_file.with_suffix("").as_posix().replace("/", ".")+        module_pkg = rel.rsplit(".", 1)[0] if "." in rel else None+    except Exception:+        module_pkg = None+    for node in ast.walk(tree):+        if isinstance(node, ast.Import):+            for alias in node.names:+                name = alias.asname or alias.name+                import_map[name] = alias.name+        elif isinstance(node, ast.ImportFrom) and node.module is not None:+            base = node.module+            # Handle relative levels (e.g., from .sub import x)+            if getattr(node, "level", 0):+                if module_pkg:+                    parts = module_pkg.split(".")+                    level = int(node.level)+                    base = ".".join(parts[: max(0, len(parts) - level)]) + (("." + base) if base else "")+                    base = base.strip(".")+            for alias in node.names:+                if alias.name != "*":+                    full_name = f"{base}.{alias.name}" if base else alias.name+                    name = alias.asname or alias.name+                    import_map[name] = full_name++    test_funcs_by_name = {tf.function_name: tf for tf in test_functions}+    result = defaultdict(list)+    normalized_targets = {t.strip(".") for t in target_qualified_names}++    for node in ast.walk(tree):+        if not isinstance(node, ast.FunctionDef) or node.name not in test_funcs_by_name:+            continue+        test_func = test_funcs_by_name[node.name]+        for child in ast.walk(node):+            if not isinstance(child, ast.Call):+                continue+            call_name = _extract_dotted_call_name(child.func)+            if not call_name:+                continue+            # direct match+            if call_name.strip(".") in normalized_targets:+                result[call_name.strip(".")].append(+                    (test_func, CodePosition(line_no=child.lineno, col_no=child.col_offset))+                )+                continue+            parts = call_name.split(".", 1)+            if parts[0] in import_map:+                resolved = f"{import_map[parts[0]]}.{parts[1]}" if len(parts) == 2 else import_map[parts[0]]+                norm = resolved.strip(".")+                if norm in normalized_targets:+                    result[norm].append((test_func, CodePosition(line_no=child.lineno, col_no=child.col_offset)))++    return dict(result)+