oracle_context_cache/DebarghaG__proofofthought.json

{"repo": "DebarghaG/proofofthought", "n_pairs": 46, "version": "v2_function_scoped", "contexts": {"tests/integration/test_interpreter.py::74": {"resolved_imports": ["z3adapter/interpreter.py"], "used_names": ["Z3JSONInterpreter", "json", "os", "tempfile"], "enclosing_function": "test_missing_sections_get_defaults", "extracted_code": "# Source: z3adapter/interpreter.py\nclass Z3JSONInterpreter:\n    \"\"\"Interpreter for Z3 DSL defined in JSON format.\"\"\"\n\n    # Default timeout values in milliseconds\n    DEFAULT_VERIFY_TIMEOUT = 10000\n    DEFAULT_OPTIMIZE_TIMEOUT = 100000\n\n    def __init__(\n        self,\n        json_file: str,\n        solver: AbstractSolver | None = None,\n        verify_timeout: int = DEFAULT_VERIFY_TIMEOUT,\n        optimize_timeout: int = DEFAULT_OPTIMIZE_TIMEOUT,\n    ):\n        \"\"\"Initialize the Z3 JSON interpreter.\n\n        Args:\n            json_file: Path to JSON configuration file\n            solver: Optional solver instance (defaults to Z3Solver)\n            verify_timeout: Timeout for verification in milliseconds\n            optimize_timeout: Timeout for optimization in milliseconds\n        \"\"\"\n        self.json_file = json_file\n        self.verify_timeout = verify_timeout\n        self.optimize_timeout = optimize_timeout\n        self.config = self.load_and_validate_json(json_file)\n        self.solver = solver if solver else Z3Solver()\n\n        # Initialize components\n        self.sort_manager = SortManager()\n        self.expression_parser: ExpressionParser | None = None\n        self.verifier: Verifier | None = None\n        self.optimizer_runner: OptimizerRunner | None = None\n\n    def load_and_validate_json(self, json_file: str) -> dict[str, Any]:\n        \"\"\"Load and validate JSON configuration file.\n\n        Args:\n            json_file: Path to JSON file\n\n        Returns:\n            Validated configuration dictionary\n\n        Raises:\n            FileNotFoundError: If JSON file doesn't exist\n            json.JSONDecodeError: If JSON is malformed\n            ValueError: If required sections are invalid\n        \"\"\"\n        try:\n            with open(json_file) as file:\n                config = json.load(file)\n        except FileNotFoundError:\n            logger.error(f\"JSON file not found: {json_file}\")\n            raise\n        except json.JSONDecodeError as e:\n            logger.error(f\"Invalid JSON in {json_file}: {e}\")\n            raise\n\n        # Initialize missing sections with appropriate defaults\n        default_sections: dict[str, Any] = {\n            \"sorts\": [],\n            \"functions\": [],\n            \"constants\": {},\n            \"knowledge_base\": [],\n            \"rules\": [],\n            \"verifications\": [],\n            \"actions\": [],\n            \"variables\": [],\n        }\n\n        for section, default in default_sections.items():\n            if section not in config:\n                config[section] = default\n                logger.debug(f\"Section '{section}' not found, using default: {default}\")\n\n        # Validate structure\n        if not isinstance(config.get(\"constants\"), dict):\n            config[\"constants\"] = {}\n            logger.warning(\"'constants' section should be a dictionary, resetting to empty dict\")\n\n        return config\n\n    def perform_actions(self) -> None:\n        \"\"\"Execute actions specified in configuration.\n\n        Actions are method names to be called on this interpreter instance.\n        \"\"\"\n        for action in self.config[\"actions\"]:\n            if hasattr(self, action):\n                try:\n                    logger.info(f\"Executing action: {action}\")\n                    getattr(self, action)()\n                except Exception as e:\n                    logger.error(f\"Error executing action '{action}': {e}\")\n                    raise\n            else:\n                logger.warning(f\"Unknown action: {action}\")\n\n    def verify_conditions(self) -> None:\n        \"\"\"Verify all defined verification conditions.\"\"\"\n        if self.verifier:\n            self.verifier.verify_conditions(self.solver, self.verify_timeout)\n\n    def get_verification_counts(self) -> tuple[int, int]:\n        \"\"\"Get SAT and UNSAT counts from verification results.\n\n        Returns:\n            Tuple of (sat_count, unsat_count)\n        \"\"\"\n        if self.verifier:\n            return (self.verifier.sat_count, self.verifier.unsat_count)\n        return (0, 0)\n\n    def optimize(self) -> None:\n        \"\"\"Run optimization if configured.\"\"\"\n        if self.optimizer_runner and \"optimization\" in self.config:\n            self.optimizer_runner.optimize(self.config[\"optimization\"], self.optimize_timeout)\n\n    def run(self) -> None:\n        \"\"\"Execute the full interpretation pipeline.\n\n        Steps:\n        1. Create sorts\n        2. Create functions\n        3. Create constants\n        4. Create variables\n        5. Add knowledge base\n        6. Add rules\n        7. Add verifications\n        8. Perform configured actions\n\n        Raises:\n            Various exceptions if any step fails\n        \"\"\"\n        try:\n            logger.info(f\"Starting interpretation of {self.json_file}\")\n\n            # Step 1: Create sorts\n            self.sort_manager.create_sorts(self.config[\"sorts\"])\n\n            # Step 2: Create functions\n            functions = self.sort_manager.create_functions(self.config[\"functions\"])\n\n            # Step 3: Create constants\n            self.sort_manager.create_constants(self.config[\"constants\"])\n\n            # Step 4: Create variables\n            variables = self.sort_manager.create_variables(self.config.get(\"variables\", []))\n\n            # Initialize expression parser with all symbols\n            self.expression_parser = ExpressionParser(\n                functions=functions, constants=self.sort_manager.constants, variables=variables\n            )\n\n            # Mark that all symbols have been loaded\n            self.expression_parser.mark_symbols_loaded()\n\n            # Step 5: Add knowledge base\n            self.expression_parser.add_knowledge_base(self.solver, self.config[\"knowledge_base\"])\n\n            # Step 6: Add rules\n            self.expression_parser.add_rules(\n                self.solver, self.config[\"rules\"], self.sort_manager.sorts\n            )\n\n            # Step 7: Initialize verifier and add verifications\n            self.verifier = Verifier(self.expression_parser, self.sort_manager.sorts)\n            self.verifier.add_verifications(self.config[\"verifications\"])\n\n            # Initialize optimizer runner\n            self.optimizer_runner = OptimizerRunner(\n                self.expression_parser, self.sort_manager.sorts, ExpressionParser.Z3_OPERATORS\n            )\n\n            # Step 8: Perform actions\n            self.perform_actions()\n\n            logger.info(\"Interpretation completed successfully\")\n        except Exception as e:\n            logger.error(f\"Interpretation failed: {e}\")\n            raise", "n_imports_parsed": 5, "n_files_resolved": 1, "n_chars_extracted": 6545}, "tests/integration/test_interpreter.py::104": {"resolved_imports": ["z3adapter/interpreter.py"], "used_names": ["Z3JSONInterpreter", "json", "os", "tempfile"], "enclosing_function": "test_unknown_action_logs_warning", "extracted_code": "# Source: z3adapter/interpreter.py\nclass Z3JSONInterpreter:\n    \"\"\"Interpreter for Z3 DSL defined in JSON format.\"\"\"\n\n    # Default timeout values in milliseconds\n    DEFAULT_VERIFY_TIMEOUT = 10000\n    DEFAULT_OPTIMIZE_TIMEOUT = 100000\n\n    def __init__(\n        self,\n        json_file: str,\n        solver: AbstractSolver | None = None,\n        verify_timeout: int = DEFAULT_VERIFY_TIMEOUT,\n        optimize_timeout: int = DEFAULT_OPTIMIZE_TIMEOUT,\n    ):\n        \"\"\"Initialize the Z3 JSON interpreter.\n\n        Args:\n            json_file: Path to JSON configuration file\n            solver: Optional solver instance (defaults to Z3Solver)\n            verify_timeout: Timeout for verification in milliseconds\n            optimize_timeout: Timeout for optimization in milliseconds\n        \"\"\"\n        self.json_file = json_file\n        self.verify_timeout = verify_timeout\n        self.optimize_timeout = optimize_timeout\n        self.config = self.load_and_validate_json(json_file)\n        self.solver = solver if solver else Z3Solver()\n\n        # Initialize components\n        self.sort_manager = SortManager()\n        self.expression_parser: ExpressionParser | None = None\n        self.verifier: Verifier | None = None\n        self.optimizer_runner: OptimizerRunner | None = None\n\n    def load_and_validate_json(self, json_file: str) -> dict[str, Any]:\n        \"\"\"Load and validate JSON configuration file.\n\n        Args:\n            json_file: Path to JSON file\n\n        Returns:\n            Validated configuration dictionary\n\n        Raises:\n            FileNotFoundError: If JSON file doesn't exist\n            json.JSONDecodeError: If JSON is malformed\n            ValueError: If required sections are invalid\n        \"\"\"\n        try:\n            with open(json_file) as file:\n                config = json.load(file)\n        except FileNotFoundError:\n            logger.error(f\"JSON file not found: {json_file}\")\n            raise\n        except json.JSONDecodeError as e:\n            logger.error(f\"Invalid JSON in {json_file}: {e}\")\n            raise\n\n        # Initialize missing sections with appropriate defaults\n        default_sections: dict[str, Any] = {\n            \"sorts\": [],\n            \"functions\": [],\n            \"constants\": {},\n            \"knowledge_base\": [],\n            \"rules\": [],\n            \"verifications\": [],\n            \"actions\": [],\n            \"variables\": [],\n        }\n\n        for section, default in default_sections.items():\n            if section not in config:\n                config[section] = default\n                logger.debug(f\"Section '{section}' not found, using default: {default}\")\n\n        # Validate structure\n        if not isinstance(config.get(\"constants\"), dict):\n            config[\"constants\"] = {}\n            logger.warning(\"'constants' section should be a dictionary, resetting to empty dict\")\n\n        return config\n\n    def perform_actions(self) -> None:\n        \"\"\"Execute actions specified in configuration.\n\n        Actions are method names to be called on this interpreter instance.\n        \"\"\"\n        for action in self.config[\"actions\"]:\n            if hasattr(self, action):\n                try:\n                    logger.info(f\"Executing action: {action}\")\n                    getattr(self, action)()\n                except Exception as e:\n                    logger.error(f\"Error executing action '{action}': {e}\")\n                    raise\n            else:\n                logger.warning(f\"Unknown action: {action}\")\n\n    def verify_conditions(self) -> None:\n        \"\"\"Verify all defined verification conditions.\"\"\"\n        if self.verifier:\n            self.verifier.verify_conditions(self.solver, self.verify_timeout)\n\n    def get_verification_counts(self) -> tuple[int, int]:\n        \"\"\"Get SAT and UNSAT counts from verification results.\n\n        Returns:\n            Tuple of (sat_count, unsat_count)\n        \"\"\"\n        if self.verifier:\n            return (self.verifier.sat_count, self.verifier.unsat_count)\n        return (0, 0)\n\n    def optimize(self) -> None:\n        \"\"\"Run optimization if configured.\"\"\"\n        if self.optimizer_runner and \"optimization\" in self.config:\n            self.optimizer_runner.optimize(self.config[\"optimization\"], self.optimize_timeout)\n\n    def run(self) -> None:\n        \"\"\"Execute the full interpretation pipeline.\n\n        Steps:\n        1. Create sorts\n        2. Create functions\n        3. Create constants\n        4. Create variables\n        5. Add knowledge base\n        6. Add rules\n        7. Add verifications\n        8. Perform configured actions\n\n        Raises:\n            Various exceptions if any step fails\n        \"\"\"\n        try:\n            logger.info(f\"Starting interpretation of {self.json_file}\")\n\n            # Step 1: Create sorts\n            self.sort_manager.create_sorts(self.config[\"sorts\"])\n\n            # Step 2: Create functions\n            functions = self.sort_manager.create_functions(self.config[\"functions\"])\n\n            # Step 3: Create constants\n            self.sort_manager.create_constants(self.config[\"constants\"])\n\n            # Step 4: Create variables\n            variables = self.sort_manager.create_variables(self.config.get(\"variables\", []))\n\n            # Initialize expression parser with all symbols\n            self.expression_parser = ExpressionParser(\n                functions=functions, constants=self.sort_manager.constants, variables=variables\n            )\n\n            # Mark that all symbols have been loaded\n            self.expression_parser.mark_symbols_loaded()\n\n            # Step 5: Add knowledge base\n            self.expression_parser.add_knowledge_base(self.solver, self.config[\"knowledge_base\"])\n\n            # Step 6: Add rules\n            self.expression_parser.add_rules(\n                self.solver, self.config[\"rules\"], self.sort_manager.sorts\n            )\n\n            # Step 7: Initialize verifier and add verifications\n            self.verifier = Verifier(self.expression_parser, self.sort_manager.sorts)\n            self.verifier.add_verifications(self.config[\"verifications\"])\n\n            # Initialize optimizer runner\n            self.optimizer_runner = OptimizerRunner(\n                self.expression_parser, self.sort_manager.sorts, ExpressionParser.Z3_OPERATORS\n            )\n\n            # Step 8: Perform actions\n            self.perform_actions()\n\n            logger.info(\"Interpretation completed successfully\")\n        except Exception as e:\n            logger.error(f\"Interpretation failed: {e}\")\n            raise", "n_imports_parsed": 5, "n_files_resolved": 1, "n_chars_extracted": 6545}, "tests/integration/test_interpreter.py::72": {"resolved_imports": ["z3adapter/interpreter.py"], "used_names": ["Z3JSONInterpreter", "json", "os", "tempfile"], "enclosing_function": "test_missing_sections_get_defaults", "extracted_code": "# Source: z3adapter/interpreter.py\nclass Z3JSONInterpreter:\n    \"\"\"Interpreter for Z3 DSL defined in JSON format.\"\"\"\n\n    # Default timeout values in milliseconds\n    DEFAULT_VERIFY_TIMEOUT = 10000\n    DEFAULT_OPTIMIZE_TIMEOUT = 100000\n\n    def __init__(\n        self,\n        json_file: str,\n        solver: AbstractSolver | None = None,\n        verify_timeout: int = DEFAULT_VERIFY_TIMEOUT,\n        optimize_timeout: int = DEFAULT_OPTIMIZE_TIMEOUT,\n    ):\n        \"\"\"Initialize the Z3 JSON interpreter.\n\n        Args:\n            json_file: Path to JSON configuration file\n            solver: Optional solver instance (defaults to Z3Solver)\n            verify_timeout: Timeout for verification in milliseconds\n            optimize_timeout: Timeout for optimization in milliseconds\n        \"\"\"\n        self.json_file = json_file\n        self.verify_timeout = verify_timeout\n        self.optimize_timeout = optimize_timeout\n        self.config = self.load_and_validate_json(json_file)\n        self.solver = solver if solver else Z3Solver()\n\n        # Initialize components\n        self.sort_manager = SortManager()\n        self.expression_parser: ExpressionParser | None = None\n        self.verifier: Verifier | None = None\n        self.optimizer_runner: OptimizerRunner | None = None\n\n    def load_and_validate_json(self, json_file: str) -> dict[str, Any]:\n        \"\"\"Load and validate JSON configuration file.\n\n        Args:\n            json_file: Path to JSON file\n\n        Returns:\n            Validated configuration dictionary\n\n        Raises:\n            FileNotFoundError: If JSON file doesn't exist\n            json.JSONDecodeError: If JSON is malformed\n            ValueError: If required sections are invalid\n        \"\"\"\n        try:\n            with open(json_file) as file:\n                config = json.load(file)\n        except FileNotFoundError:\n            logger.error(f\"JSON file not found: {json_file}\")\n            raise\n        except json.JSONDecodeError as e:\n            logger.error(f\"Invalid JSON in {json_file}: {e}\")\n            raise\n\n        # Initialize missing sections with appropriate defaults\n        default_sections: dict[str, Any] = {\n            \"sorts\": [],\n            \"functions\": [],\n            \"constants\": {},\n            \"knowledge_base\": [],\n            \"rules\": [],\n            \"verifications\": [],\n            \"actions\": [],\n            \"variables\": [],\n        }\n\n        for section, default in default_sections.items():\n            if section not in config:\n                config[section] = default\n                logger.debug(f\"Section '{section}' not found, using default: {default}\")\n\n        # Validate structure\n        if not isinstance(config.get(\"constants\"), dict):\n            config[\"constants\"] = {}\n            logger.warning(\"'constants' section should be a dictionary, resetting to empty dict\")\n\n        return config\n\n    def perform_actions(self) -> None:\n        \"\"\"Execute actions specified in configuration.\n\n        Actions are method names to be called on this interpreter instance.\n        \"\"\"\n        for action in self.config[\"actions\"]:\n            if hasattr(self, action):\n                try:\n                    logger.info(f\"Executing action: {action}\")\n                    getattr(self, action)()\n                except Exception as e:\n                    logger.error(f\"Error executing action '{action}': {e}\")\n                    raise\n            else:\n                logger.warning(f\"Unknown action: {action}\")\n\n    def verify_conditions(self) -> None:\n        \"\"\"Verify all defined verification conditions.\"\"\"\n        if self.verifier:\n            self.verifier.verify_conditions(self.solver, self.verify_timeout)\n\n    def get_verification_counts(self) -> tuple[int, int]:\n        \"\"\"Get SAT and UNSAT counts from verification results.\n\n        Returns:\n            Tuple of (sat_count, unsat_count)\n        \"\"\"\n        if self.verifier:\n            return (self.verifier.sat_count, self.verifier.unsat_count)\n        return (0, 0)\n\n    def optimize(self) -> None:\n        \"\"\"Run optimization if configured.\"\"\"\n        if self.optimizer_runner and \"optimization\" in self.config:\n            self.optimizer_runner.optimize(self.config[\"optimization\"], self.optimize_timeout)\n\n    def run(self) -> None:\n        \"\"\"Execute the full interpretation pipeline.\n\n        Steps:\n        1. Create sorts\n        2. Create functions\n        3. Create constants\n        4. Create variables\n        5. Add knowledge base\n        6. Add rules\n        7. Add verifications\n        8. Perform configured actions\n\n        Raises:\n            Various exceptions if any step fails\n        \"\"\"\n        try:\n            logger.info(f\"Starting interpretation of {self.json_file}\")\n\n            # Step 1: Create sorts\n            self.sort_manager.create_sorts(self.config[\"sorts\"])\n\n            # Step 2: Create functions\n            functions = self.sort_manager.create_functions(self.config[\"functions\"])\n\n            # Step 3: Create constants\n            self.sort_manager.create_constants(self.config[\"constants\"])\n\n            # Step 4: Create variables\n            variables = self.sort_manager.create_variables(self.config.get(\"variables\", []))\n\n            # Initialize expression parser with all symbols\n            self.expression_parser = ExpressionParser(\n                functions=functions, constants=self.sort_manager.constants, variables=variables\n            )\n\n            # Mark that all symbols have been loaded\n            self.expression_parser.mark_symbols_loaded()\n\n            # Step 5: Add knowledge base\n            self.expression_parser.add_knowledge_base(self.solver, self.config[\"knowledge_base\"])\n\n            # Step 6: Add rules\n            self.expression_parser.add_rules(\n                self.solver, self.config[\"rules\"], self.sort_manager.sorts\n            )\n\n            # Step 7: Initialize verifier and add verifications\n            self.verifier = Verifier(self.expression_parser, self.sort_manager.sorts)\n            self.verifier.add_verifications(self.config[\"verifications\"])\n\n            # Initialize optimizer runner\n            self.optimizer_runner = OptimizerRunner(\n                self.expression_parser, self.sort_manager.sorts, ExpressionParser.Z3_OPERATORS\n            )\n\n            # Step 8: Perform actions\n            self.perform_actions()\n\n            logger.info(\"Interpretation completed successfully\")\n        except Exception as e:\n            logger.error(f\"Interpretation failed: {e}\")\n            raise", "n_imports_parsed": 5, "n_files_resolved": 1, "n_chars_extracted": 6545}, "tests/integration/test_bug_fixes.py::61": {"resolved_imports": ["z3adapter/dsl/expressions.py", "z3adapter/dsl/sorts.py", "z3adapter/interpreter.py", "z3adapter/security/validator.py"], "used_names": ["ExpressionValidator", "ast"], "enclosing_function": "test_bug5_security_sandbox_ast_based", "extracted_code": "# Source: z3adapter/security/validator.py\nclass ExpressionValidator:\n    \"\"\"Validates expressions for security issues before evaluation.\"\"\"\n\n    @staticmethod\n    def check_safe_ast(node: ast.AST, expr_str: str) -> None:\n        \"\"\"Check AST for dangerous constructs.\n\n        Args:\n            node: AST node to check\n            expr_str: Original expression string for error messages\n\n        Raises:\n            ValueError: If dangerous construct found\n        \"\"\"\n        for n in ast.walk(node):\n            # Block attribute access to dunder methods\n            if isinstance(n, ast.Attribute):\n                if n.attr.startswith(\"__\") and n.attr.endswith(\"__\"):\n                    raise ValueError(\n                        f\"Access to dunder attribute '{n.attr}' not allowed in '{expr_str}'\"\n                    )\n            # Block imports\n            elif isinstance(n, (ast.Import, ast.ImportFrom)):\n                raise ValueError(f\"Import statements not allowed in '{expr_str}'\")\n            # Block function/class definitions\n            elif isinstance(n, (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef)):\n                raise ValueError(f\"Function/class definitions not allowed in '{expr_str}'\")\n            # Block exec/eval\n            elif isinstance(n, ast.Call):\n                if isinstance(n.func, ast.Name) and n.func.id in (\n                    \"eval\",\n                    \"exec\",\n                    \"compile\",\n                    \"__import__\",\n                ):\n                    raise ValueError(f\"Call to '{n.func.id}' not allowed in '{expr_str}'\")\n\n    @staticmethod\n    def safe_eval(expr_str: str, safe_globals: dict[str, Any], context: dict[str, Any]) -> Any:\n        \"\"\"Safely evaluate expression string with restricted globals.\n\n        Args:\n            expr_str: Expression string to evaluate\n            safe_globals: Safe global functions/operators\n            context: Local context dictionary\n\n        Returns:\n            Evaluated expression\n\n        Raises:\n            ValueError: If expression cannot be evaluated safely\n        \"\"\"\n        try:\n            # Parse to AST and check for dangerous constructs\n            tree = ast.parse(expr_str, mode=\"eval\")\n            ExpressionValidator.check_safe_ast(tree, expr_str)\n\n            # Compile and evaluate with restricted builtins\n            code = compile(tree, \"<string>\", \"eval\")\n            return eval(code, {\"__builtins__\": {}}, {**safe_globals, **context})\n        except SyntaxError as e:\n            raise ValueError(f\"Syntax error in expression '{expr_str}': {e}\") from e\n        except NameError as e:\n            raise ValueError(f\"Undefined name in expression '{expr_str}': {e}\") from e\n        except Exception as e:\n            raise ValueError(f\"Error evaluating expression '{expr_str}': {e}\") from e", "n_imports_parsed": 9, "n_files_resolved": 4, "n_chars_extracted": 2832}, "tests/unit/test_sort_manager.py::22": {"resolved_imports": ["z3adapter/dsl/sorts.py"], "used_names": ["BoolSort", "IntSort", "RealSort"], "enclosing_function": "test_builtin_sorts_initialized", "extracted_code": "", "n_imports_parsed": 3, "n_files_resolved": 1, "n_chars_extracted": 0}, "tests/unit/test_expression_parser.py::84": {"resolved_imports": ["z3adapter/dsl/expressions.py"], "used_names": [], "enclosing_function": "test_parse_expression_with_invalid_syntax", "extracted_code": "", "n_imports_parsed": 4, "n_files_resolved": 1, "n_chars_extracted": 0}, "tests/integration/test_bug_fixes.py::38": {"resolved_imports": ["z3adapter/dsl/expressions.py", "z3adapter/dsl/sorts.py", "z3adapter/interpreter.py", "z3adapter/security/validator.py"], "used_names": ["ExpressionParser"], "enclosing_function": "test_bug3_context_cache_timing_fixed", "extracted_code": "# Source: z3adapter/dsl/expressions.py\nclass ExpressionParser:\n    \"\"\"Parses and evaluates Z3 expressions from strings.\"\"\"\n\n    # Safe Z3 operators allowed in expressions\n    Z3_OPERATORS = {\n        \"And\": And,\n        \"Or\": Or,\n        \"Not\": Not,\n        \"Implies\": Implies,\n        \"If\": If,\n        \"Distinct\": Distinct,\n        \"Sum\": Sum,\n        \"Product\": Product,\n        \"ForAll\": ForAll,\n        \"Exists\": Exists,\n        \"Function\": Function,\n        \"Array\": Array,\n        \"BitVecVal\": BitVecVal,\n    }\n\n    def __init__(\n        self, functions: dict[str, Any], constants: dict[str, Any], variables: dict[str, Any]\n    ):\n        \"\"\"Initialize expression parser.\n\n        Args:\n            functions: Z3 function declarations\n            constants: Z3 constants\n            variables: Z3 variables\n        \"\"\"\n        self.functions = functions\n        self.constants = constants\n        self.variables = variables\n        self._context_cache: dict[str, Any] | None = None\n        self._symbols_loaded = False\n\n    def mark_symbols_loaded(self) -> None:\n        \"\"\"Mark that all symbols have been loaded and enable caching.\"\"\"\n        self._symbols_loaded = True\n\n    def build_context(self, quantified_vars: list[ExprRef] | None = None) -> dict[str, Any]:\n        \"\"\"Build evaluation context with all defined symbols.\n\n        Args:\n            quantified_vars: Optional quantified variables to include\n\n        Returns:\n            Dictionary mapping names to Z3 objects\n        \"\"\"\n        # Only cache context after all symbols have been loaded\n        if self._context_cache is None and self._symbols_loaded:\n            # Build base context once (after all sorts, functions, constants, variables loaded)\n            self._context_cache = {}\n            self._context_cache.update(self.functions)\n            self._context_cache.update(self.constants)\n            self._context_cache.update(self.variables)\n\n        # If not cached yet, build context dynamically\n        if self._context_cache is None:\n            context = {}\n            context.update(self.functions)\n            context.update(self.constants)\n            context.update(self.variables)\n        else:\n            context = self._context_cache.copy()\n\n        if not quantified_vars:\n            return context\n\n        # Add quantified variables to context\n        # Check for shadowing\n        for v in quantified_vars:\n            var_name = v.decl().name()\n            if var_name in context and var_name not in [\n                vv.decl().name() for vv in quantified_vars[: quantified_vars.index(v)]\n            ]:\n                logger.warning(f\"Quantified variable '{var_name}' shadows existing symbol\")\n            context[var_name] = v\n        return context\n\n    def parse_expression(\n        self, expr_str: str, quantified_vars: list[ExprRef] | None = None\n    ) -> ExprRef:\n        \"\"\"Parse expression string into Z3 expression.\n\n        Args:\n            expr_str: Expression string to parse\n            quantified_vars: Optional list of quantified variables\n\n        Returns:\n            Parsed Z3 expression\n\n        Raises:\n            ValueError: If expression cannot be parsed\n        \"\"\"\n        context = self.build_context(quantified_vars)\n        safe_globals = {**self.Z3_OPERATORS, **self.functions}\n        return ExpressionValidator.safe_eval(expr_str, safe_globals, context)\n\n    def add_knowledge_base(self, solver: Any, knowledge_base: list[Any]) -> None:\n        \"\"\"Add knowledge base assertions to solver.\n\n        Args:\n            solver: Solver instance\n            knowledge_base: List of assertions\n\n        Raises:\n            ValueError: If assertion is invalid\n        \"\"\"\n        context = self.build_context()\n        safe_globals = {**self.Z3_OPERATORS, **self.functions}\n\n        for assertion_entry in knowledge_base:\n            if isinstance(assertion_entry, dict):\n                assertion_str = assertion_entry[\"assertion\"]\n                value = assertion_entry.get(\"value\", True)\n            else:\n                assertion_str = assertion_entry\n                value = True\n\n            try:\n                expr = ExpressionValidator.safe_eval(assertion_str, safe_globals, context)\n                if not value:\n                    expr = Not(expr)\n                solver.add(expr)\n                logger.debug(f\"Added knowledge base assertion: {assertion_str[:50]}...\")\n            except Exception as e:\n                logger.error(f\"Error parsing assertion '{assertion_str}': {e}\")\n                raise\n\n    def add_rules(self, solver: Any, rules: list[dict[str, Any]], sorts: dict[str, Any]) -> None:\n        \"\"\"Add logical rules to solver.\n\n        Args:\n            solver: Solver instance\n            rules: List of rule definitions\n            sorts: Z3 sorts dictionary\n\n        Raises:\n            ValueError: If rule is invalid\n        \"\"\"\n        for rule in rules:\n            try:\n                forall_vars = rule.get(\"forall\", [])\n\n                # Validate that if forall is specified, it's not empty\n                if \"forall\" in rule and not forall_vars:\n                    raise ValueError(\n                        \"Empty 'forall' list in rule - remove 'forall' key if no quantification needed\"\n                    )\n\n                variables = [Const(v[\"name\"], sorts[v[\"sort\"]]) for v in forall_vars]\n\n                if \"implies\" in rule:\n                    if not variables:\n                        raise ValueError(\n                            \"Implication rules require quantified variables - use 'forall' key\"\n                        )\n                    antecedent = self.parse_expression(rule[\"implies\"][\"antecedent\"], variables)\n                    consequent = self.parse_expression(rule[\"implies\"][\"consequent\"], variables)\n                    solver.add(ForAll(variables, Implies(antecedent, consequent)))\n                    logger.debug(f\"Added implication rule with {len(variables)} variables\")\n                elif \"constraint\" in rule:\n                    constraint = self.parse_expression(rule[\"constraint\"], variables)\n                    if variables:\n                        solver.add(ForAll(variables, constraint))\n                    else:\n                        solver.add(constraint)\n                    logger.debug(\"Added constraint rule\")\n                else:\n                    raise ValueError(\n                        f\"Invalid rule (must contain 'implies' or 'constraint'): {rule}\"\n                    )\n            except Exception as e:\n                logger.error(f\"Error adding rule: {e}\")\n                raise", "n_imports_parsed": 9, "n_files_resolved": 4, "n_chars_extracted": 6629}, "tests/unit/test_sort_manager.py::59": {"resolved_imports": ["z3adapter/dsl/sorts.py"], "used_names": [], "enclosing_function": "test_create_bitvec_sort_zero_size", "extracted_code": "", "n_imports_parsed": 3, "n_files_resolved": 1, "n_chars_extracted": 0}, "tests/unit/test_sort_manager.py::142": {"resolved_imports": ["z3adapter/dsl/sorts.py"], "used_names": [], "enclosing_function": "test_create_functions", "extracted_code": "", "n_imports_parsed": 3, "n_files_resolved": 1, "n_chars_extracted": 0}, "tests/unit/test_security_validator.py::134": {"resolved_imports": ["z3adapter/security/validator.py"], "used_names": ["ExpressionValidator"], "enclosing_function": "test_safe_eval_allows_normal_attribute_access", "extracted_code": "# Source: z3adapter/security/validator.py\nclass ExpressionValidator:\n    \"\"\"Validates expressions for security issues before evaluation.\"\"\"\n\n    @staticmethod\n    def check_safe_ast(node: ast.AST, expr_str: str) -> None:\n        \"\"\"Check AST for dangerous constructs.\n\n        Args:\n            node: AST node to check\n            expr_str: Original expression string for error messages\n\n        Raises:\n            ValueError: If dangerous construct found\n        \"\"\"\n        for n in ast.walk(node):\n            # Block attribute access to dunder methods\n            if isinstance(n, ast.Attribute):\n                if n.attr.startswith(\"__\") and n.attr.endswith(\"__\"):\n                    raise ValueError(\n                        f\"Access to dunder attribute '{n.attr}' not allowed in '{expr_str}'\"\n                    )\n            # Block imports\n            elif isinstance(n, (ast.Import, ast.ImportFrom)):\n                raise ValueError(f\"Import statements not allowed in '{expr_str}'\")\n            # Block function/class definitions\n            elif isinstance(n, (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef)):\n                raise ValueError(f\"Function/class definitions not allowed in '{expr_str}'\")\n            # Block exec/eval\n            elif isinstance(n, ast.Call):\n                if isinstance(n.func, ast.Name) and n.func.id in (\n                    \"eval\",\n                    \"exec\",\n                    \"compile\",\n                    \"__import__\",\n                ):\n                    raise ValueError(f\"Call to '{n.func.id}' not allowed in '{expr_str}'\")\n\n    @staticmethod\n    def safe_eval(expr_str: str, safe_globals: dict[str, Any], context: dict[str, Any]) -> Any:\n        \"\"\"Safely evaluate expression string with restricted globals.\n\n        Args:\n            expr_str: Expression string to evaluate\n            safe_globals: Safe global functions/operators\n            context: Local context dictionary\n\n        Returns:\n            Evaluated expression\n\n        Raises:\n            ValueError: If expression cannot be evaluated safely\n        \"\"\"\n        try:\n            # Parse to AST and check for dangerous constructs\n            tree = ast.parse(expr_str, mode=\"eval\")\n            ExpressionValidator.check_safe_ast(tree, expr_str)\n\n            # Compile and evaluate with restricted builtins\n            code = compile(tree, \"<string>\", \"eval\")\n            return eval(code, {\"__builtins__\": {}}, {**safe_globals, **context})\n        except SyntaxError as e:\n            raise ValueError(f\"Syntax error in expression '{expr_str}': {e}\") from e\n        except NameError as e:\n            raise ValueError(f\"Undefined name in expression '{expr_str}': {e}\") from e\n        except Exception as e:\n            raise ValueError(f\"Error evaluating expression '{expr_str}': {e}\") from e", "n_imports_parsed": 3, "n_files_resolved": 1, "n_chars_extracted": 2832}, "tests/integration/test_bug_fixes.py::113": {"resolved_imports": ["z3adapter/dsl/expressions.py", "z3adapter/dsl/sorts.py", "z3adapter/interpreter.py", "z3adapter/security/validator.py"], "used_names": ["SortManager"], "enclosing_function": "test_bug8_constants_dict_semantics_fixed", "extracted_code": "# Source: z3adapter/dsl/sorts.py\nclass SortManager:\n    \"\"\"Manages Z3 sort creation and dependencies.\"\"\"\n\n    MAX_BITVEC_SIZE = 65536  # Maximum reasonable bitvector size\n\n    def __init__(self) -> None:\n        self.sorts: dict[str, SortRef] = {}\n        self.constants: dict[str, Any] = {}\n        self._initialize_builtin_sorts()\n\n    def _initialize_builtin_sorts(self) -> None:\n        \"\"\"Initialize built-in Z3 sorts.\"\"\"\n        built_in_sorts = {\"BoolSort\": BoolSort(), \"IntSort\": IntSort(), \"RealSort\": RealSort()}\n        self.sorts.update(built_in_sorts)\n\n    @staticmethod\n    def _topological_sort_sorts(sort_defs: list[dict[str, Any]]) -> list[dict[str, Any]]:\n        \"\"\"Topologically sort sort definitions to handle dependencies.\n\n        Args:\n            sort_defs: List of sort definitions\n\n        Returns:\n            Sorted list where dependencies come before dependents\n\n        Raises:\n            ValueError: If circular dependency detected or missing name field\n        \"\"\"\n        # Build dependency graph\n        dependencies = {}\n        for sort_def in sort_defs:\n            if \"name\" not in sort_def:\n                raise ValueError(f\"Sort definition missing 'name' field: {sort_def}\")\n            name = sort_def[\"name\"]\n            sort_type = sort_def[\"type\"]\n            deps = []\n\n            # Extract dependencies based on sort type\n            if sort_type.startswith(\"ArraySort(\"):\n                domain_range = sort_type[len(\"ArraySort(\") : -1]\n                parts = [s.strip() for s in domain_range.split(\",\")]\n                deps.extend(parts)\n\n            dependencies[name] = deps\n\n        # Perform topological sort using Kahn's algorithm\n        # in_degree = number of dependencies a sort has\n        in_degree = {}\n        for name, deps in dependencies.items():\n            # Count only user-defined dependencies (not built-ins)\n            user_deps = [d for d in deps if d in dependencies]\n            in_degree[name] = len(user_deps)\n\n        # Start with nodes that have no dependencies\n        queue = [name for name, degree in in_degree.items() if degree == 0]\n        sorted_names = []\n\n        while queue:\n            current = queue.pop(0)\n            sorted_names.append(current)\n\n            # Reduce in-degree for sorts that depend on current\n            for name, deps in dependencies.items():\n                if current in deps and name not in sorted_names:\n                    in_degree[name] -= 1\n                    if in_degree[name] == 0:\n                        queue.append(name)\n\n        # Check for cycles\n        if len(sorted_names) != len(dependencies):\n            remaining = set(dependencies.keys()) - set(sorted_names)\n            raise ValueError(f\"Circular dependency detected in sorts: {remaining}\")\n\n        # Reorder sort_defs according to sorted_names\n        name_to_def = {s[\"name\"]: s for s in sort_defs}\n        return [name_to_def[name] for name in sorted_names]\n\n    def create_sorts(self, sort_defs: list[dict[str, Any]]) -> None:\n        \"\"\"Create Z3 sorts from definitions.\n\n        Args:\n            sort_defs: List of sort definitions\n\n        Raises:\n            ValueError: If sort definition is invalid\n        \"\"\"\n        # Topologically sort sorts to handle dependencies\n        sorted_sort_defs = self._topological_sort_sorts(sort_defs)\n\n        # Create user-defined sorts in dependency order\n        for sort_def in sorted_sort_defs:\n            try:\n                name = sort_def[\"name\"]\n                sort_type = sort_def[\"type\"]\n\n                if sort_type == \"EnumSort\":\n                    values = sort_def[\"values\"]\n                    enum_sort, enum_consts = EnumSort(name, values)\n                    self.sorts[name] = enum_sort\n                    # Add enum constants to context\n                    for val_name, const in zip(values, enum_consts, strict=False):\n                        self.constants[val_name] = const\n                elif sort_type.startswith(\"BitVecSort(\"):\n                    size_str = sort_type[len(\"BitVecSort(\") : -1].strip()\n                    try:\n                        size = int(size_str)\n                        if size <= 0:\n                            raise ValueError(f\"BitVecSort size must be positive, got {size}\")\n                        if size > self.MAX_BITVEC_SIZE:\n                            raise ValueError(\n                                f\"BitVecSort size {size} exceeds maximum {self.MAX_BITVEC_SIZE}\"\n                            )\n                        self.sorts[name] = BitVecSort(size)\n                    except ValueError as e:\n                        raise ValueError(f\"Invalid BitVecSort size '{size_str}': {e}\") from e\n                elif sort_type.startswith(\"ArraySort(\"):\n                    domain_range = sort_type[len(\"ArraySort(\") : -1]\n                    domain_sort_name, range_sort_name = [s.strip() for s in domain_range.split(\",\")]\n                    domain_sort = self.sorts.get(domain_sort_name)\n                    range_sort = self.sorts.get(range_sort_name)\n                    if domain_sort is None or range_sort is None:\n                        raise ValueError(\n                            f\"ArraySort references undefined sorts: {domain_sort_name}, {range_sort_name}\"\n                        )\n                    self.sorts[name] = ArraySort(domain_sort, range_sort)\n                elif sort_type == \"IntSort\":\n                    self.sorts[name] = IntSort()\n                elif sort_type == \"RealSort\":\n                    self.sorts[name] = RealSort()\n                elif sort_type == \"BoolSort\":\n                    self.sorts[name] = BoolSort()\n                elif sort_type == \"DeclareSort\":\n                    self.sorts[name] = DeclareSort(name)\n                else:\n                    raise ValueError(f\"Unknown sort type: {sort_type}\")\n                logger.debug(f\"Created sort: {name} ({sort_type})\")\n            except KeyError as e:\n                logger.error(f\"Missing required field in sort definition: {e}\")\n                raise ValueError(f\"Invalid sort definition {sort_def}: missing {e}\") from e\n            except Exception as e:\n                logger.error(f\"Error creating sort '{name}': {e}\")\n                raise\n\n    def create_functions(self, func_defs: list[dict[str, Any]]) -> dict[str, Any]:\n        \"\"\"Create Z3 functions from definitions.\n\n        Args:\n            func_defs: List of function definitions\n\n        Returns:\n            Dictionary mapping function names to Z3 function declarations\n\n        Raises:\n            ValueError: If function definition is invalid\n        \"\"\"\n        from z3 import Function\n\n        functions = {}\n        for func_def in func_defs:\n            try:\n                name = func_def[\"name\"]\n                # Validate domain sorts exist\n                for sort_name in func_def[\"domain\"]:\n                    if sort_name not in self.sorts:\n                        raise ValueError(f\"Sort '{sort_name}' not defined\")\n                domain = [self.sorts[sort] for sort in func_def[\"domain\"]]\n                # Validate range sort exists\n                range_sort_name = func_def[\"range\"]\n                if range_sort_name not in self.sorts:\n                    raise ValueError(f\"Sort '{range_sort_name}' not defined\")\n                range_sort = self.sorts[range_sort_name]\n                functions[name] = Function(name, *domain, range_sort)\n                logger.debug(f\"Created function: {name}\")\n            except KeyError as e:\n                logger.error(f\"Missing required field in function definition: {e}\")\n                raise ValueError(f\"Invalid function definition {func_def}: missing {e}\") from e\n            except Exception as e:\n                logger.error(f\"Error creating function '{name}': {e}\")\n                raise\n        return functions\n\n    def create_constants(self, constants_defs: dict[str, Any]) -> None:\n        \"\"\"Create Z3 constants from definitions.\n\n        Args:\n            constants_defs: Dictionary of constant definitions\n\n        Raises:\n            ValueError: If constant definition is invalid\n        \"\"\"\n        for category, constants in constants_defs.items():\n            try:\n                sort_name = constants[\"sort\"]\n                if sort_name not in self.sorts:\n                    raise ValueError(f\"Sort '{sort_name}' not defined\")\n\n                if isinstance(constants[\"members\"], list):\n                    # List format: [\"name1\", \"name2\"] -> create constants with those names\n                    self.constants.update(\n                        {c: Const(c, self.sorts[sort_name]) for c in constants[\"members\"]}\n                    )\n                elif isinstance(constants[\"members\"], dict):\n                    # Dict format: {\"ref_name\": \"z3_name\"} -> create constant with z3_name\n                    # FIX: Use key as both reference name AND Z3 constant name for consistency\n                    self.constants.update(\n                        {\n                            k: Const(k, self.sorts[sort_name])\n                            for k, v in constants[\"members\"].items()\n                        }\n                    )\n                    logger.debug(\n                        \"Note: Dict values in constants are deprecated, using keys as Z3 names\"\n                    )\n                else:\n                    logger.warning(f\"Invalid members format for category '{category}', skipping\")\n                logger.debug(f\"Created constants for category: {category}\")\n            except KeyError as e:\n                logger.error(\n                    f\"Missing required field in constants definition for '{category}': {e}\"\n                )\n                raise ValueError(f\"Invalid constants definition: missing {e}\") from e\n            except Exception as e:\n                logger.error(f\"Error creating constants for category '{category}': {e}\")\n                raise\n\n    def create_variables(self, var_defs: list[dict[str, Any]]) -> dict[str, Any]:\n        \"\"\"Create Z3 variables from definitions.\n\n        Args:\n            var_defs: List of variable definitions\n\n        Returns:\n            Dictionary mapping variable names to Z3 constants\n\n        Raises:\n            ValueError: If variable definition is invalid\n        \"\"\"\n        variables = {}\n        for var_def in var_defs:\n            try:\n                name = var_def[\"name\"]\n                sort_name = var_def[\"sort\"]\n                if sort_name not in self.sorts:\n                    raise ValueError(f\"Sort '{sort_name}' not defined\")\n                sort = self.sorts[sort_name]\n                variables[name] = Const(name, sort)\n                logger.debug(f\"Created variable: {name} of sort {sort_name}\")\n            except KeyError as e:\n                logger.error(f\"Missing required field in variable definition: {e}\")\n                raise ValueError(f\"Invalid variable definition {var_def}: missing {e}\") from e\n            except Exception as e:\n                logger.error(f\"Error creating variable '{name}': {e}\")\n                raise\n        return variables", "n_imports_parsed": 9, "n_files_resolved": 4, "n_chars_extracted": 11145}, "tests/integration/test_interpreter.py::50": {"resolved_imports": ["z3adapter/interpreter.py"], "used_names": ["Z3JSONInterpreter", "json", "os", "tempfile"], "enclosing_function": "test_load_invalid_json", "extracted_code": "# Source: z3adapter/interpreter.py\nclass Z3JSONInterpreter:\n    \"\"\"Interpreter for Z3 DSL defined in JSON format.\"\"\"\n\n    # Default timeout values in milliseconds\n    DEFAULT_VERIFY_TIMEOUT = 10000\n    DEFAULT_OPTIMIZE_TIMEOUT = 100000\n\n    def __init__(\n        self,\n        json_file: str,\n        solver: AbstractSolver | None = None,\n        verify_timeout: int = DEFAULT_VERIFY_TIMEOUT,\n        optimize_timeout: int = DEFAULT_OPTIMIZE_TIMEOUT,\n    ):\n        \"\"\"Initialize the Z3 JSON interpreter.\n\n        Args:\n            json_file: Path to JSON configuration file\n            solver: Optional solver instance (defaults to Z3Solver)\n            verify_timeout: Timeout for verification in milliseconds\n            optimize_timeout: Timeout for optimization in milliseconds\n        \"\"\"\n        self.json_file = json_file\n        self.verify_timeout = verify_timeout\n        self.optimize_timeout = optimize_timeout\n        self.config = self.load_and_validate_json(json_file)\n        self.solver = solver if solver else Z3Solver()\n\n        # Initialize components\n        self.sort_manager = SortManager()\n        self.expression_parser: ExpressionParser | None = None\n        self.verifier: Verifier | None = None\n        self.optimizer_runner: OptimizerRunner | None = None\n\n    def load_and_validate_json(self, json_file: str) -> dict[str, Any]:\n        \"\"\"Load and validate JSON configuration file.\n\n        Args:\n            json_file: Path to JSON file\n\n        Returns:\n            Validated configuration dictionary\n\n        Raises:\n            FileNotFoundError: If JSON file doesn't exist\n            json.JSONDecodeError: If JSON is malformed\n            ValueError: If required sections are invalid\n        \"\"\"\n        try:\n            with open(json_file) as file:\n                config = json.load(file)\n        except FileNotFoundError:\n            logger.error(f\"JSON file not found: {json_file}\")\n            raise\n        except json.JSONDecodeError as e:\n            logger.error(f\"Invalid JSON in {json_file}: {e}\")\n            raise\n\n        # Initialize missing sections with appropriate defaults\n        default_sections: dict[str, Any] = {\n            \"sorts\": [],\n            \"functions\": [],\n            \"constants\": {},\n            \"knowledge_base\": [],\n            \"rules\": [],\n            \"verifications\": [],\n            \"actions\": [],\n            \"variables\": [],\n        }\n\n        for section, default in default_sections.items():\n            if section not in config:\n                config[section] = default\n                logger.debug(f\"Section '{section}' not found, using default: {default}\")\n\n        # Validate structure\n        if not isinstance(config.get(\"constants\"), dict):\n            config[\"constants\"] = {}\n            logger.warning(\"'constants' section should be a dictionary, resetting to empty dict\")\n\n        return config\n\n    def perform_actions(self) -> None:\n        \"\"\"Execute actions specified in configuration.\n\n        Actions are method names to be called on this interpreter instance.\n        \"\"\"\n        for action in self.config[\"actions\"]:\n            if hasattr(self, action):\n                try:\n                    logger.info(f\"Executing action: {action}\")\n                    getattr(self, action)()\n                except Exception as e:\n                    logger.error(f\"Error executing action '{action}': {e}\")\n                    raise\n            else:\n                logger.warning(f\"Unknown action: {action}\")\n\n    def verify_conditions(self) -> None:\n        \"\"\"Verify all defined verification conditions.\"\"\"\n        if self.verifier:\n            self.verifier.verify_conditions(self.solver, self.verify_timeout)\n\n    def get_verification_counts(self) -> tuple[int, int]:\n        \"\"\"Get SAT and UNSAT counts from verification results.\n\n        Returns:\n            Tuple of (sat_count, unsat_count)\n        \"\"\"\n        if self.verifier:\n            return (self.verifier.sat_count, self.verifier.unsat_count)\n        return (0, 0)\n\n    def optimize(self) -> None:\n        \"\"\"Run optimization if configured.\"\"\"\n        if self.optimizer_runner and \"optimization\" in self.config:\n            self.optimizer_runner.optimize(self.config[\"optimization\"], self.optimize_timeout)\n\n    def run(self) -> None:\n        \"\"\"Execute the full interpretation pipeline.\n\n        Steps:\n        1. Create sorts\n        2. Create functions\n        3. Create constants\n        4. Create variables\n        5. Add knowledge base\n        6. Add rules\n        7. Add verifications\n        8. Perform configured actions\n\n        Raises:\n            Various exceptions if any step fails\n        \"\"\"\n        try:\n            logger.info(f\"Starting interpretation of {self.json_file}\")\n\n            # Step 1: Create sorts\n            self.sort_manager.create_sorts(self.config[\"sorts\"])\n\n            # Step 2: Create functions\n            functions = self.sort_manager.create_functions(self.config[\"functions\"])\n\n            # Step 3: Create constants\n            self.sort_manager.create_constants(self.config[\"constants\"])\n\n            # Step 4: Create variables\n            variables = self.sort_manager.create_variables(self.config.get(\"variables\", []))\n\n            # Initialize expression parser with all symbols\n            self.expression_parser = ExpressionParser(\n                functions=functions, constants=self.sort_manager.constants, variables=variables\n            )\n\n            # Mark that all symbols have been loaded\n            self.expression_parser.mark_symbols_loaded()\n\n            # Step 5: Add knowledge base\n            self.expression_parser.add_knowledge_base(self.solver, self.config[\"knowledge_base\"])\n\n            # Step 6: Add rules\n            self.expression_parser.add_rules(\n                self.solver, self.config[\"rules\"], self.sort_manager.sorts\n            )\n\n            # Step 7: Initialize verifier and add verifications\n            self.verifier = Verifier(self.expression_parser, self.sort_manager.sorts)\n            self.verifier.add_verifications(self.config[\"verifications\"])\n\n            # Initialize optimizer runner\n            self.optimizer_runner = OptimizerRunner(\n                self.expression_parser, self.sort_manager.sorts, ExpressionParser.Z3_OPERATORS\n            )\n\n            # Step 8: Perform actions\n            self.perform_actions()\n\n            logger.info(\"Interpretation completed successfully\")\n        except Exception as e:\n            logger.error(f\"Interpretation failed: {e}\")\n            raise", "n_imports_parsed": 5, "n_files_resolved": 1, "n_chars_extracted": 6545}, "tests/unit/test_security_validator.py::39": {"resolved_imports": ["z3adapter/security/validator.py"], "used_names": ["ast"], "enclosing_function": "test_check_safe_ast_blocks_import", "extracted_code": "", "n_imports_parsed": 3, "n_files_resolved": 1, "n_chars_extracted": 0}, "tests/unit/test_sort_manager.py::23": {"resolved_imports": ["z3adapter/dsl/sorts.py"], "used_names": ["BoolSort", "IntSort", "RealSort"], "enclosing_function": "test_builtin_sorts_initialized", "extracted_code": "", "n_imports_parsed": 3, "n_files_resolved": 1, "n_chars_extracted": 0}, "tests/unit/test_verifier.py::60": {"resolved_imports": ["z3adapter/dsl/expressions.py", "z3adapter/solvers/z3_solver.py", "z3adapter/verification/verifier.py"], "used_names": [], "enclosing_function": "test_add_verification_empty_exists_raises_error", "extracted_code": "", "n_imports_parsed": 6, "n_files_resolved": 3, "n_chars_extracted": 0}, "tests/unit/test_verifier.py::99": {"resolved_imports": ["z3adapter/dsl/expressions.py", "z3adapter/solvers/z3_solver.py", "z3adapter/verification/verifier.py"], "used_names": ["Z3Solver"], "enclosing_function": "test_verify_conditions_sat", "extracted_code": "# Source: z3adapter/solvers/z3_solver.py\nclass Z3Solver(AbstractSolver):\n    \"\"\"Z3 solver implementation.\"\"\"\n\n    def __init__(self) -> None:\n        self.solver = Solver()\n\n    def add(self, constraint: Any) -> None:\n        \"\"\"Add a constraint to the Z3 solver.\"\"\"\n        self.solver.add(constraint)\n\n    def check(self, condition: Any = None) -> Any:\n        \"\"\"Check satisfiability with optional condition.\"\"\"\n        if condition is not None:\n            return self.solver.check(condition)\n        return self.solver.check()\n\n    def model(self) -> Any:\n        \"\"\"Return the satisfying model.\"\"\"\n        return self.solver.model()\n\n    def set(self, param: str, value: Any) -> None:\n        \"\"\"Set Z3 solver parameter.\"\"\"\n        self.solver.set(param, value)", "n_imports_parsed": 6, "n_files_resolved": 3, "n_chars_extracted": 767}, "tests/unit/test_verifier.py::29": {"resolved_imports": ["z3adapter/dsl/expressions.py", "z3adapter/solvers/z3_solver.py", "z3adapter/verification/verifier.py"], "used_names": [], "enclosing_function": "test_add_verification_simple_constraint", "extracted_code": "", "n_imports_parsed": 6, "n_files_resolved": 3, "n_chars_extracted": 0}, "tests/integration/test_bug_fixes.py::24": {"resolved_imports": ["z3adapter/dsl/expressions.py", "z3adapter/dsl/sorts.py", "z3adapter/interpreter.py", "z3adapter/security/validator.py"], "used_names": [], "enclosing_function": "test_bug1_wildcard_import_fixed", "extracted_code": "", "n_imports_parsed": 9, "n_files_resolved": 4, "n_chars_extracted": 0}, "tests/unit/test_verifier.py::58": {"resolved_imports": ["z3adapter/dsl/expressions.py", "z3adapter/solvers/z3_solver.py", "z3adapter/verification/verifier.py"], "used_names": [], "enclosing_function": "test_add_verification_empty_exists_raises_error", "extracted_code": "", "n_imports_parsed": 6, "n_files_resolved": 3, "n_chars_extracted": 0}, "tests/unit/test_sort_manager.py::178": {"resolved_imports": ["z3adapter/dsl/sorts.py"], "used_names": [], "enclosing_function": "test_create_variables", "extracted_code": "", "n_imports_parsed": 3, "n_files_resolved": 1, "n_chars_extracted": 0}, "tests/unit/test_optimizer.py::28": {"resolved_imports": ["z3adapter/dsl/expressions.py", "z3adapter/optimization/optimizer.py"], "used_names": [], "enclosing_function": "test_optimize_no_config", "extracted_code": "", "n_imports_parsed": 5, "n_files_resolved": 2, "n_chars_extracted": 0}, "tests/unit/test_sort_manager.py::57": {"resolved_imports": ["z3adapter/dsl/sorts.py"], "used_names": [], "enclosing_function": "test_create_bitvec_sort_zero_size", "extracted_code": "", "n_imports_parsed": 3, "n_files_resolved": 1, "n_chars_extracted": 0}, "tests/unit/test_security_validator.py::95": {"resolved_imports": ["z3adapter/security/validator.py"], "used_names": ["And", "BoolVal", "ExpressionValidator"], "enclosing_function": "test_safe_eval_uses_safe_globals", "extracted_code": "# Source: z3adapter/security/validator.py\nclass ExpressionValidator:\n    \"\"\"Validates expressions for security issues before evaluation.\"\"\"\n\n    @staticmethod\n    def check_safe_ast(node: ast.AST, expr_str: str) -> None:\n        \"\"\"Check AST for dangerous constructs.\n\n        Args:\n            node: AST node to check\n            expr_str: Original expression string for error messages\n\n        Raises:\n            ValueError: If dangerous construct found\n        \"\"\"\n        for n in ast.walk(node):\n            # Block attribute access to dunder methods\n            if isinstance(n, ast.Attribute):\n                if n.attr.startswith(\"__\") and n.attr.endswith(\"__\"):\n                    raise ValueError(\n                        f\"Access to dunder attribute '{n.attr}' not allowed in '{expr_str}'\"\n                    )\n            # Block imports\n            elif isinstance(n, (ast.Import, ast.ImportFrom)):\n                raise ValueError(f\"Import statements not allowed in '{expr_str}'\")\n            # Block function/class definitions\n            elif isinstance(n, (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef)):\n                raise ValueError(f\"Function/class definitions not allowed in '{expr_str}'\")\n            # Block exec/eval\n            elif isinstance(n, ast.Call):\n                if isinstance(n.func, ast.Name) and n.func.id in (\n                    \"eval\",\n                    \"exec\",\n                    \"compile\",\n                    \"__import__\",\n                ):\n                    raise ValueError(f\"Call to '{n.func.id}' not allowed in '{expr_str}'\")\n\n    @staticmethod\n    def safe_eval(expr_str: str, safe_globals: dict[str, Any], context: dict[str, Any]) -> Any:\n        \"\"\"Safely evaluate expression string with restricted globals.\n\n        Args:\n            expr_str: Expression string to evaluate\n            safe_globals: Safe global functions/operators\n            context: Local context dictionary\n\n        Returns:\n            Evaluated expression\n\n        Raises:\n            ValueError: If expression cannot be evaluated safely\n        \"\"\"\n        try:\n            # Parse to AST and check for dangerous constructs\n            tree = ast.parse(expr_str, mode=\"eval\")\n            ExpressionValidator.check_safe_ast(tree, expr_str)\n\n            # Compile and evaluate with restricted builtins\n            code = compile(tree, \"<string>\", \"eval\")\n            return eval(code, {\"__builtins__\": {}}, {**safe_globals, **context})\n        except SyntaxError as e:\n            raise ValueError(f\"Syntax error in expression '{expr_str}': {e}\") from e\n        except NameError as e:\n            raise ValueError(f\"Undefined name in expression '{expr_str}': {e}\") from e\n        except Exception as e:\n            raise ValueError(f\"Error evaluating expression '{expr_str}': {e}\") from e", "n_imports_parsed": 4, "n_files_resolved": 1, "n_chars_extracted": 2832}, "tests/unit/test_optimizer.py::76": {"resolved_imports": ["z3adapter/dsl/expressions.py", "z3adapter/optimization/optimizer.py"], "used_names": [], "enclosing_function": "test_optimize_references_global_constants", "extracted_code": "", "n_imports_parsed": 5, "n_files_resolved": 2, "n_chars_extracted": 0}, "tests/unit/test_expression_parser.py::63": {"resolved_imports": ["z3adapter/dsl/expressions.py"], "used_names": [], "enclosing_function": "test_build_context_with_symbols_loaded", "extracted_code": "", "n_imports_parsed": 4, "n_files_resolved": 1, "n_chars_extracted": 0}, "tests/integration/test_interpreter.py::40": {"resolved_imports": ["z3adapter/interpreter.py"], "used_names": ["Z3JSONInterpreter"], "enclosing_function": "test_load_nonexistent_file", "extracted_code": "# Source: z3adapter/interpreter.py\nclass Z3JSONInterpreter:\n    \"\"\"Interpreter for Z3 DSL defined in JSON format.\"\"\"\n\n    # Default timeout values in milliseconds\n    DEFAULT_VERIFY_TIMEOUT = 10000\n    DEFAULT_OPTIMIZE_TIMEOUT = 100000\n\n    def __init__(\n        self,\n        json_file: str,\n        solver: AbstractSolver | None = None,\n        verify_timeout: int = DEFAULT_VERIFY_TIMEOUT,\n        optimize_timeout: int = DEFAULT_OPTIMIZE_TIMEOUT,\n    ):\n        \"\"\"Initialize the Z3 JSON interpreter.\n\n        Args:\n            json_file: Path to JSON configuration file\n            solver: Optional solver instance (defaults to Z3Solver)\n            verify_timeout: Timeout for verification in milliseconds\n            optimize_timeout: Timeout for optimization in milliseconds\n        \"\"\"\n        self.json_file = json_file\n        self.verify_timeout = verify_timeout\n        self.optimize_timeout = optimize_timeout\n        self.config = self.load_and_validate_json(json_file)\n        self.solver = solver if solver else Z3Solver()\n\n        # Initialize components\n        self.sort_manager = SortManager()\n        self.expression_parser: ExpressionParser | None = None\n        self.verifier: Verifier | None = None\n        self.optimizer_runner: OptimizerRunner | None = None\n\n    def load_and_validate_json(self, json_file: str) -> dict[str, Any]:\n        \"\"\"Load and validate JSON configuration file.\n\n        Args:\n            json_file: Path to JSON file\n\n        Returns:\n            Validated configuration dictionary\n\n        Raises:\n            FileNotFoundError: If JSON file doesn't exist\n            json.JSONDecodeError: If JSON is malformed\n            ValueError: If required sections are invalid\n        \"\"\"\n        try:\n            with open(json_file) as file:\n                config = json.load(file)\n        except FileNotFoundError:\n            logger.error(f\"JSON file not found: {json_file}\")\n            raise\n        except json.JSONDecodeError as e:\n            logger.error(f\"Invalid JSON in {json_file}: {e}\")\n            raise\n\n        # Initialize missing sections with appropriate defaults\n        default_sections: dict[str, Any] = {\n            \"sorts\": [],\n            \"functions\": [],\n            \"constants\": {},\n            \"knowledge_base\": [],\n            \"rules\": [],\n            \"verifications\": [],\n            \"actions\": [],\n            \"variables\": [],\n        }\n\n        for section, default in default_sections.items():\n            if section not in config:\n                config[section] = default\n                logger.debug(f\"Section '{section}' not found, using default: {default}\")\n\n        # Validate structure\n        if not isinstance(config.get(\"constants\"), dict):\n            config[\"constants\"] = {}\n            logger.warning(\"'constants' section should be a dictionary, resetting to empty dict\")\n\n        return config\n\n    def perform_actions(self) -> None:\n        \"\"\"Execute actions specified in configuration.\n\n        Actions are method names to be called on this interpreter instance.\n        \"\"\"\n        for action in self.config[\"actions\"]:\n            if hasattr(self, action):\n                try:\n                    logger.info(f\"Executing action: {action}\")\n                    getattr(self, action)()\n                except Exception as e:\n                    logger.error(f\"Error executing action '{action}': {e}\")\n                    raise\n            else:\n                logger.warning(f\"Unknown action: {action}\")\n\n    def verify_conditions(self) -> None:\n        \"\"\"Verify all defined verification conditions.\"\"\"\n        if self.verifier:\n            self.verifier.verify_conditions(self.solver, self.verify_timeout)\n\n    def get_verification_counts(self) -> tuple[int, int]:\n        \"\"\"Get SAT and UNSAT counts from verification results.\n\n        Returns:\n            Tuple of (sat_count, unsat_count)\n        \"\"\"\n        if self.verifier:\n            return (self.verifier.sat_count, self.verifier.unsat_count)\n        return (0, 0)\n\n    def optimize(self) -> None:\n        \"\"\"Run optimization if configured.\"\"\"\n        if self.optimizer_runner and \"optimization\" in self.config:\n            self.optimizer_runner.optimize(self.config[\"optimization\"], self.optimize_timeout)\n\n    def run(self) -> None:\n        \"\"\"Execute the full interpretation pipeline.\n\n        Steps:\n        1. Create sorts\n        2. Create functions\n        3. Create constants\n        4. Create variables\n        5. Add knowledge base\n        6. Add rules\n        7. Add verifications\n        8. Perform configured actions\n\n        Raises:\n            Various exceptions if any step fails\n        \"\"\"\n        try:\n            logger.info(f\"Starting interpretation of {self.json_file}\")\n\n            # Step 1: Create sorts\n            self.sort_manager.create_sorts(self.config[\"sorts\"])\n\n            # Step 2: Create functions\n            functions = self.sort_manager.create_functions(self.config[\"functions\"])\n\n            # Step 3: Create constants\n            self.sort_manager.create_constants(self.config[\"constants\"])\n\n            # Step 4: Create variables\n            variables = self.sort_manager.create_variables(self.config.get(\"variables\", []))\n\n            # Initialize expression parser with all symbols\n            self.expression_parser = ExpressionParser(\n                functions=functions, constants=self.sort_manager.constants, variables=variables\n            )\n\n            # Mark that all symbols have been loaded\n            self.expression_parser.mark_symbols_loaded()\n\n            # Step 5: Add knowledge base\n            self.expression_parser.add_knowledge_base(self.solver, self.config[\"knowledge_base\"])\n\n            # Step 6: Add rules\n            self.expression_parser.add_rules(\n                self.solver, self.config[\"rules\"], self.sort_manager.sorts\n            )\n\n            # Step 7: Initialize verifier and add verifications\n            self.verifier = Verifier(self.expression_parser, self.sort_manager.sorts)\n            self.verifier.add_verifications(self.config[\"verifications\"])\n\n            # Initialize optimizer runner\n            self.optimizer_runner = OptimizerRunner(\n                self.expression_parser, self.sort_manager.sorts, ExpressionParser.Z3_OPERATORS\n            )\n\n            # Step 8: Perform actions\n            self.perform_actions()\n\n            logger.info(\"Interpretation completed successfully\")\n        except Exception as e:\n            logger.error(f\"Interpretation failed: {e}\")\n            raise", "n_imports_parsed": 5, "n_files_resolved": 1, "n_chars_extracted": 6545}, "tests/integration/test_interpreter.py::90": {"resolved_imports": ["z3adapter/interpreter.py"], "used_names": ["Z3JSONInterpreter", "json", "os", "tempfile"], "enclosing_function": "test_invalid_constants_section_structure", "extracted_code": "# Source: z3adapter/interpreter.py\nclass Z3JSONInterpreter:\n    \"\"\"Interpreter for Z3 DSL defined in JSON format.\"\"\"\n\n    # Default timeout values in milliseconds\n    DEFAULT_VERIFY_TIMEOUT = 10000\n    DEFAULT_OPTIMIZE_TIMEOUT = 100000\n\n    def __init__(\n        self,\n        json_file: str,\n        solver: AbstractSolver | None = None,\n        verify_timeout: int = DEFAULT_VERIFY_TIMEOUT,\n        optimize_timeout: int = DEFAULT_OPTIMIZE_TIMEOUT,\n    ):\n        \"\"\"Initialize the Z3 JSON interpreter.\n\n        Args:\n            json_file: Path to JSON configuration file\n            solver: Optional solver instance (defaults to Z3Solver)\n            verify_timeout: Timeout for verification in milliseconds\n            optimize_timeout: Timeout for optimization in milliseconds\n        \"\"\"\n        self.json_file = json_file\n        self.verify_timeout = verify_timeout\n        self.optimize_timeout = optimize_timeout\n        self.config = self.load_and_validate_json(json_file)\n        self.solver = solver if solver else Z3Solver()\n\n        # Initialize components\n        self.sort_manager = SortManager()\n        self.expression_parser: ExpressionParser | None = None\n        self.verifier: Verifier | None = None\n        self.optimizer_runner: OptimizerRunner | None = None\n\n    def load_and_validate_json(self, json_file: str) -> dict[str, Any]:\n        \"\"\"Load and validate JSON configuration file.\n\n        Args:\n            json_file: Path to JSON file\n\n        Returns:\n            Validated configuration dictionary\n\n        Raises:\n            FileNotFoundError: If JSON file doesn't exist\n            json.JSONDecodeError: If JSON is malformed\n            ValueError: If required sections are invalid\n        \"\"\"\n        try:\n            with open(json_file) as file:\n                config = json.load(file)\n        except FileNotFoundError:\n            logger.error(f\"JSON file not found: {json_file}\")\n            raise\n        except json.JSONDecodeError as e:\n            logger.error(f\"Invalid JSON in {json_file}: {e}\")\n            raise\n\n        # Initialize missing sections with appropriate defaults\n        default_sections: dict[str, Any] = {\n            \"sorts\": [],\n            \"functions\": [],\n            \"constants\": {},\n            \"knowledge_base\": [],\n            \"rules\": [],\n            \"verifications\": [],\n            \"actions\": [],\n            \"variables\": [],\n        }\n\n        for section, default in default_sections.items():\n            if section not in config:\n                config[section] = default\n                logger.debug(f\"Section '{section}' not found, using default: {default}\")\n\n        # Validate structure\n        if not isinstance(config.get(\"constants\"), dict):\n            config[\"constants\"] = {}\n            logger.warning(\"'constants' section should be a dictionary, resetting to empty dict\")\n\n        return config\n\n    def perform_actions(self) -> None:\n        \"\"\"Execute actions specified in configuration.\n\n        Actions are method names to be called on this interpreter instance.\n        \"\"\"\n        for action in self.config[\"actions\"]:\n            if hasattr(self, action):\n                try:\n                    logger.info(f\"Executing action: {action}\")\n                    getattr(self, action)()\n                except Exception as e:\n                    logger.error(f\"Error executing action '{action}': {e}\")\n                    raise\n            else:\n                logger.warning(f\"Unknown action: {action}\")\n\n    def verify_conditions(self) -> None:\n        \"\"\"Verify all defined verification conditions.\"\"\"\n        if self.verifier:\n            self.verifier.verify_conditions(self.solver, self.verify_timeout)\n\n    def get_verification_counts(self) -> tuple[int, int]:\n        \"\"\"Get SAT and UNSAT counts from verification results.\n\n        Returns:\n            Tuple of (sat_count, unsat_count)\n        \"\"\"\n        if self.verifier:\n            return (self.verifier.sat_count, self.verifier.unsat_count)\n        return (0, 0)\n\n    def optimize(self) -> None:\n        \"\"\"Run optimization if configured.\"\"\"\n        if self.optimizer_runner and \"optimization\" in self.config:\n            self.optimizer_runner.optimize(self.config[\"optimization\"], self.optimize_timeout)\n\n    def run(self) -> None:\n        \"\"\"Execute the full interpretation pipeline.\n\n        Steps:\n        1. Create sorts\n        2. Create functions\n        3. Create constants\n        4. Create variables\n        5. Add knowledge base\n        6. Add rules\n        7. Add verifications\n        8. Perform configured actions\n\n        Raises:\n            Various exceptions if any step fails\n        \"\"\"\n        try:\n            logger.info(f\"Starting interpretation of {self.json_file}\")\n\n            # Step 1: Create sorts\n            self.sort_manager.create_sorts(self.config[\"sorts\"])\n\n            # Step 2: Create functions\n            functions = self.sort_manager.create_functions(self.config[\"functions\"])\n\n            # Step 3: Create constants\n            self.sort_manager.create_constants(self.config[\"constants\"])\n\n            # Step 4: Create variables\n            variables = self.sort_manager.create_variables(self.config.get(\"variables\", []))\n\n            # Initialize expression parser with all symbols\n            self.expression_parser = ExpressionParser(\n                functions=functions, constants=self.sort_manager.constants, variables=variables\n            )\n\n            # Mark that all symbols have been loaded\n            self.expression_parser.mark_symbols_loaded()\n\n            # Step 5: Add knowledge base\n            self.expression_parser.add_knowledge_base(self.solver, self.config[\"knowledge_base\"])\n\n            # Step 6: Add rules\n            self.expression_parser.add_rules(\n                self.solver, self.config[\"rules\"], self.sort_manager.sorts\n            )\n\n            # Step 7: Initialize verifier and add verifications\n            self.verifier = Verifier(self.expression_parser, self.sort_manager.sorts)\n            self.verifier.add_verifications(self.config[\"verifications\"])\n\n            # Initialize optimizer runner\n            self.optimizer_runner = OptimizerRunner(\n                self.expression_parser, self.sort_manager.sorts, ExpressionParser.Z3_OPERATORS\n            )\n\n            # Step 8: Perform actions\n            self.perform_actions()\n\n            logger.info(\"Interpretation completed successfully\")\n        except Exception as e:\n            logger.error(f\"Interpretation failed: {e}\")\n            raise", "n_imports_parsed": 5, "n_files_resolved": 1, "n_chars_extracted": 6545}, "tests/unit/test_security_validator.py::85": {"resolved_imports": ["z3adapter/security/validator.py"], "used_names": ["ExpressionValidator"], "enclosing_function": "test_safe_eval_uses_context", "extracted_code": "# Source: z3adapter/security/validator.py\nclass ExpressionValidator:\n    \"\"\"Validates expressions for security issues before evaluation.\"\"\"\n\n    @staticmethod\n    def check_safe_ast(node: ast.AST, expr_str: str) -> None:\n        \"\"\"Check AST for dangerous constructs.\n\n        Args:\n            node: AST node to check\n            expr_str: Original expression string for error messages\n\n        Raises:\n            ValueError: If dangerous construct found\n        \"\"\"\n        for n in ast.walk(node):\n            # Block attribute access to dunder methods\n            if isinstance(n, ast.Attribute):\n                if n.attr.startswith(\"__\") and n.attr.endswith(\"__\"):\n                    raise ValueError(\n                        f\"Access to dunder attribute '{n.attr}' not allowed in '{expr_str}'\"\n                    )\n            # Block imports\n            elif isinstance(n, (ast.Import, ast.ImportFrom)):\n                raise ValueError(f\"Import statements not allowed in '{expr_str}'\")\n            # Block function/class definitions\n            elif isinstance(n, (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef)):\n                raise ValueError(f\"Function/class definitions not allowed in '{expr_str}'\")\n            # Block exec/eval\n            elif isinstance(n, ast.Call):\n                if isinstance(n.func, ast.Name) and n.func.id in (\n                    \"eval\",\n                    \"exec\",\n                    \"compile\",\n                    \"__import__\",\n                ):\n                    raise ValueError(f\"Call to '{n.func.id}' not allowed in '{expr_str}'\")\n\n    @staticmethod\n    def safe_eval(expr_str: str, safe_globals: dict[str, Any], context: dict[str, Any]) -> Any:\n        \"\"\"Safely evaluate expression string with restricted globals.\n\n        Args:\n            expr_str: Expression string to evaluate\n            safe_globals: Safe global functions/operators\n            context: Local context dictionary\n\n        Returns:\n            Evaluated expression\n\n        Raises:\n            ValueError: If expression cannot be evaluated safely\n        \"\"\"\n        try:\n            # Parse to AST and check for dangerous constructs\n            tree = ast.parse(expr_str, mode=\"eval\")\n            ExpressionValidator.check_safe_ast(tree, expr_str)\n\n            # Compile and evaluate with restricted builtins\n            code = compile(tree, \"<string>\", \"eval\")\n            return eval(code, {\"__builtins__\": {}}, {**safe_globals, **context})\n        except SyntaxError as e:\n            raise ValueError(f\"Syntax error in expression '{expr_str}': {e}\") from e\n        except NameError as e:\n            raise ValueError(f\"Undefined name in expression '{expr_str}': {e}\") from e\n        except Exception as e:\n            raise ValueError(f\"Error evaluating expression '{expr_str}': {e}\") from e", "n_imports_parsed": 3, "n_files_resolved": 1, "n_chars_extracted": 2832}, "tests/integration/test_interpreter.py::126": {"resolved_imports": ["z3adapter/interpreter.py"], "used_names": ["Z3JSONInterpreter", "json", "os", "tempfile"], "enclosing_function": "test_verify_conditions_action", "extracted_code": "# Source: z3adapter/interpreter.py\nclass Z3JSONInterpreter:\n    \"\"\"Interpreter for Z3 DSL defined in JSON format.\"\"\"\n\n    # Default timeout values in milliseconds\n    DEFAULT_VERIFY_TIMEOUT = 10000\n    DEFAULT_OPTIMIZE_TIMEOUT = 100000\n\n    def __init__(\n        self,\n        json_file: str,\n        solver: AbstractSolver | None = None,\n        verify_timeout: int = DEFAULT_VERIFY_TIMEOUT,\n        optimize_timeout: int = DEFAULT_OPTIMIZE_TIMEOUT,\n    ):\n        \"\"\"Initialize the Z3 JSON interpreter.\n\n        Args:\n            json_file: Path to JSON configuration file\n            solver: Optional solver instance (defaults to Z3Solver)\n            verify_timeout: Timeout for verification in milliseconds\n            optimize_timeout: Timeout for optimization in milliseconds\n        \"\"\"\n        self.json_file = json_file\n        self.verify_timeout = verify_timeout\n        self.optimize_timeout = optimize_timeout\n        self.config = self.load_and_validate_json(json_file)\n        self.solver = solver if solver else Z3Solver()\n\n        # Initialize components\n        self.sort_manager = SortManager()\n        self.expression_parser: ExpressionParser | None = None\n        self.verifier: Verifier | None = None\n        self.optimizer_runner: OptimizerRunner | None = None\n\n    def load_and_validate_json(self, json_file: str) -> dict[str, Any]:\n        \"\"\"Load and validate JSON configuration file.\n\n        Args:\n            json_file: Path to JSON file\n\n        Returns:\n            Validated configuration dictionary\n\n        Raises:\n            FileNotFoundError: If JSON file doesn't exist\n            json.JSONDecodeError: If JSON is malformed\n            ValueError: If required sections are invalid\n        \"\"\"\n        try:\n            with open(json_file) as file:\n                config = json.load(file)\n        except FileNotFoundError:\n            logger.error(f\"JSON file not found: {json_file}\")\n            raise\n        except json.JSONDecodeError as e:\n            logger.error(f\"Invalid JSON in {json_file}: {e}\")\n            raise\n\n        # Initialize missing sections with appropriate defaults\n        default_sections: dict[str, Any] = {\n            \"sorts\": [],\n            \"functions\": [],\n            \"constants\": {},\n            \"knowledge_base\": [],\n            \"rules\": [],\n            \"verifications\": [],\n            \"actions\": [],\n            \"variables\": [],\n        }\n\n        for section, default in default_sections.items():\n            if section not in config:\n                config[section] = default\n                logger.debug(f\"Section '{section}' not found, using default: {default}\")\n\n        # Validate structure\n        if not isinstance(config.get(\"constants\"), dict):\n            config[\"constants\"] = {}\n            logger.warning(\"'constants' section should be a dictionary, resetting to empty dict\")\n\n        return config\n\n    def perform_actions(self) -> None:\n        \"\"\"Execute actions specified in configuration.\n\n        Actions are method names to be called on this interpreter instance.\n        \"\"\"\n        for action in self.config[\"actions\"]:\n            if hasattr(self, action):\n                try:\n                    logger.info(f\"Executing action: {action}\")\n                    getattr(self, action)()\n                except Exception as e:\n                    logger.error(f\"Error executing action '{action}': {e}\")\n                    raise\n            else:\n                logger.warning(f\"Unknown action: {action}\")\n\n    def verify_conditions(self) -> None:\n        \"\"\"Verify all defined verification conditions.\"\"\"\n        if self.verifier:\n            self.verifier.verify_conditions(self.solver, self.verify_timeout)\n\n    def get_verification_counts(self) -> tuple[int, int]:\n        \"\"\"Get SAT and UNSAT counts from verification results.\n\n        Returns:\n            Tuple of (sat_count, unsat_count)\n        \"\"\"\n        if self.verifier:\n            return (self.verifier.sat_count, self.verifier.unsat_count)\n        return (0, 0)\n\n    def optimize(self) -> None:\n        \"\"\"Run optimization if configured.\"\"\"\n        if self.optimizer_runner and \"optimization\" in self.config:\n            self.optimizer_runner.optimize(self.config[\"optimization\"], self.optimize_timeout)\n\n    def run(self) -> None:\n        \"\"\"Execute the full interpretation pipeline.\n\n        Steps:\n        1. Create sorts\n        2. Create functions\n        3. Create constants\n        4. Create variables\n        5. Add knowledge base\n        6. Add rules\n        7. Add verifications\n        8. Perform configured actions\n\n        Raises:\n            Various exceptions if any step fails\n        \"\"\"\n        try:\n            logger.info(f\"Starting interpretation of {self.json_file}\")\n\n            # Step 1: Create sorts\n            self.sort_manager.create_sorts(self.config[\"sorts\"])\n\n            # Step 2: Create functions\n            functions = self.sort_manager.create_functions(self.config[\"functions\"])\n\n            # Step 3: Create constants\n            self.sort_manager.create_constants(self.config[\"constants\"])\n\n            # Step 4: Create variables\n            variables = self.sort_manager.create_variables(self.config.get(\"variables\", []))\n\n            # Initialize expression parser with all symbols\n            self.expression_parser = ExpressionParser(\n                functions=functions, constants=self.sort_manager.constants, variables=variables\n            )\n\n            # Mark that all symbols have been loaded\n            self.expression_parser.mark_symbols_loaded()\n\n            # Step 5: Add knowledge base\n            self.expression_parser.add_knowledge_base(self.solver, self.config[\"knowledge_base\"])\n\n            # Step 6: Add rules\n            self.expression_parser.add_rules(\n                self.solver, self.config[\"rules\"], self.sort_manager.sorts\n            )\n\n            # Step 7: Initialize verifier and add verifications\n            self.verifier = Verifier(self.expression_parser, self.sort_manager.sorts)\n            self.verifier.add_verifications(self.config[\"verifications\"])\n\n            # Initialize optimizer runner\n            self.optimizer_runner = OptimizerRunner(\n                self.expression_parser, self.sort_manager.sorts, ExpressionParser.Z3_OPERATORS\n            )\n\n            # Step 8: Perform actions\n            self.perform_actions()\n\n            logger.info(\"Interpretation completed successfully\")\n        except Exception as e:\n            logger.error(f\"Interpretation failed: {e}\")\n            raise", "n_imports_parsed": 5, "n_files_resolved": 1, "n_chars_extracted": 6545}, "tests/unit/test_verifier.py::118": {"resolved_imports": ["z3adapter/dsl/expressions.py", "z3adapter/solvers/z3_solver.py", "z3adapter/verification/verifier.py"], "used_names": ["Z3Solver"], "enclosing_function": "test_verify_conditions_no_verifications", "extracted_code": "# Source: z3adapter/solvers/z3_solver.py\nclass Z3Solver(AbstractSolver):\n    \"\"\"Z3 solver implementation.\"\"\"\n\n    def __init__(self) -> None:\n        self.solver = Solver()\n\n    def add(self, constraint: Any) -> None:\n        \"\"\"Add a constraint to the Z3 solver.\"\"\"\n        self.solver.add(constraint)\n\n    def check(self, condition: Any = None) -> Any:\n        \"\"\"Check satisfiability with optional condition.\"\"\"\n        if condition is not None:\n            return self.solver.check(condition)\n        return self.solver.check()\n\n    def model(self) -> Any:\n        \"\"\"Return the satisfying model.\"\"\"\n        return self.solver.model()\n\n    def set(self, param: str, value: Any) -> None:\n        \"\"\"Set Z3 solver parameter.\"\"\"\n        self.solver.set(param, value)", "n_imports_parsed": 6, "n_files_resolved": 3, "n_chars_extracted": 767}, "tests/integration/test_interpreter.py::60": {"resolved_imports": ["z3adapter/interpreter.py"], "used_names": ["Z3JSONInterpreter"], "enclosing_function": "test_custom_timeouts", "extracted_code": "# Source: z3adapter/interpreter.py\nclass Z3JSONInterpreter:\n    \"\"\"Interpreter for Z3 DSL defined in JSON format.\"\"\"\n\n    # Default timeout values in milliseconds\n    DEFAULT_VERIFY_TIMEOUT = 10000\n    DEFAULT_OPTIMIZE_TIMEOUT = 100000\n\n    def __init__(\n        self,\n        json_file: str,\n        solver: AbstractSolver | None = None,\n        verify_timeout: int = DEFAULT_VERIFY_TIMEOUT,\n        optimize_timeout: int = DEFAULT_OPTIMIZE_TIMEOUT,\n    ):\n        \"\"\"Initialize the Z3 JSON interpreter.\n\n        Args:\n            json_file: Path to JSON configuration file\n            solver: Optional solver instance (defaults to Z3Solver)\n            verify_timeout: Timeout for verification in milliseconds\n            optimize_timeout: Timeout for optimization in milliseconds\n        \"\"\"\n        self.json_file = json_file\n        self.verify_timeout = verify_timeout\n        self.optimize_timeout = optimize_timeout\n        self.config = self.load_and_validate_json(json_file)\n        self.solver = solver if solver else Z3Solver()\n\n        # Initialize components\n        self.sort_manager = SortManager()\n        self.expression_parser: ExpressionParser | None = None\n        self.verifier: Verifier | None = None\n        self.optimizer_runner: OptimizerRunner | None = None\n\n    def load_and_validate_json(self, json_file: str) -> dict[str, Any]:\n        \"\"\"Load and validate JSON configuration file.\n\n        Args:\n            json_file: Path to JSON file\n\n        Returns:\n            Validated configuration dictionary\n\n        Raises:\n            FileNotFoundError: If JSON file doesn't exist\n            json.JSONDecodeError: If JSON is malformed\n            ValueError: If required sections are invalid\n        \"\"\"\n        try:\n            with open(json_file) as file:\n                config = json.load(file)\n        except FileNotFoundError:\n            logger.error(f\"JSON file not found: {json_file}\")\n            raise\n        except json.JSONDecodeError as e:\n            logger.error(f\"Invalid JSON in {json_file}: {e}\")\n            raise\n\n        # Initialize missing sections with appropriate defaults\n        default_sections: dict[str, Any] = {\n            \"sorts\": [],\n            \"functions\": [],\n            \"constants\": {},\n            \"knowledge_base\": [],\n            \"rules\": [],\n            \"verifications\": [],\n            \"actions\": [],\n            \"variables\": [],\n        }\n\n        for section, default in default_sections.items():\n            if section not in config:\n                config[section] = default\n                logger.debug(f\"Section '{section}' not found, using default: {default}\")\n\n        # Validate structure\n        if not isinstance(config.get(\"constants\"), dict):\n            config[\"constants\"] = {}\n            logger.warning(\"'constants' section should be a dictionary, resetting to empty dict\")\n\n        return config\n\n    def perform_actions(self) -> None:\n        \"\"\"Execute actions specified in configuration.\n\n        Actions are method names to be called on this interpreter instance.\n        \"\"\"\n        for action in self.config[\"actions\"]:\n            if hasattr(self, action):\n                try:\n                    logger.info(f\"Executing action: {action}\")\n                    getattr(self, action)()\n                except Exception as e:\n                    logger.error(f\"Error executing action '{action}': {e}\")\n                    raise\n            else:\n                logger.warning(f\"Unknown action: {action}\")\n\n    def verify_conditions(self) -> None:\n        \"\"\"Verify all defined verification conditions.\"\"\"\n        if self.verifier:\n            self.verifier.verify_conditions(self.solver, self.verify_timeout)\n\n    def get_verification_counts(self) -> tuple[int, int]:\n        \"\"\"Get SAT and UNSAT counts from verification results.\n\n        Returns:\n            Tuple of (sat_count, unsat_count)\n        \"\"\"\n        if self.verifier:\n            return (self.verifier.sat_count, self.verifier.unsat_count)\n        return (0, 0)\n\n    def optimize(self) -> None:\n        \"\"\"Run optimization if configured.\"\"\"\n        if self.optimizer_runner and \"optimization\" in self.config:\n            self.optimizer_runner.optimize(self.config[\"optimization\"], self.optimize_timeout)\n\n    def run(self) -> None:\n        \"\"\"Execute the full interpretation pipeline.\n\n        Steps:\n        1. Create sorts\n        2. Create functions\n        3. Create constants\n        4. Create variables\n        5. Add knowledge base\n        6. Add rules\n        7. Add verifications\n        8. Perform configured actions\n\n        Raises:\n            Various exceptions if any step fails\n        \"\"\"\n        try:\n            logger.info(f\"Starting interpretation of {self.json_file}\")\n\n            # Step 1: Create sorts\n            self.sort_manager.create_sorts(self.config[\"sorts\"])\n\n            # Step 2: Create functions\n            functions = self.sort_manager.create_functions(self.config[\"functions\"])\n\n            # Step 3: Create constants\n            self.sort_manager.create_constants(self.config[\"constants\"])\n\n            # Step 4: Create variables\n            variables = self.sort_manager.create_variables(self.config.get(\"variables\", []))\n\n            # Initialize expression parser with all symbols\n            self.expression_parser = ExpressionParser(\n                functions=functions, constants=self.sort_manager.constants, variables=variables\n            )\n\n            # Mark that all symbols have been loaded\n            self.expression_parser.mark_symbols_loaded()\n\n            # Step 5: Add knowledge base\n            self.expression_parser.add_knowledge_base(self.solver, self.config[\"knowledge_base\"])\n\n            # Step 6: Add rules\n            self.expression_parser.add_rules(\n                self.solver, self.config[\"rules\"], self.sort_manager.sorts\n            )\n\n            # Step 7: Initialize verifier and add verifications\n            self.verifier = Verifier(self.expression_parser, self.sort_manager.sorts)\n            self.verifier.add_verifications(self.config[\"verifications\"])\n\n            # Initialize optimizer runner\n            self.optimizer_runner = OptimizerRunner(\n                self.expression_parser, self.sort_manager.sorts, ExpressionParser.Z3_OPERATORS\n            )\n\n            # Step 8: Perform actions\n            self.perform_actions()\n\n            logger.info(\"Interpretation completed successfully\")\n        except Exception as e:\n            logger.error(f\"Interpretation failed: {e}\")\n            raise", "n_imports_parsed": 5, "n_files_resolved": 1, "n_chars_extracted": 6545}, "tests/unit/test_expression_parser.py::62": {"resolved_imports": ["z3adapter/dsl/expressions.py"], "used_names": [], "enclosing_function": "test_build_context_with_symbols_loaded", "extracted_code": "", "n_imports_parsed": 4, "n_files_resolved": 1, "n_chars_extracted": 0}, "tests/unit/test_expression_parser.py::51": {"resolved_imports": ["z3adapter/dsl/expressions.py"], "used_names": [], "enclosing_function": "test_build_context_without_symbols_loaded", "extracted_code": "", "n_imports_parsed": 4, "n_files_resolved": 1, "n_chars_extracted": 0}, "tests/unit/test_verifier.py::111": {"resolved_imports": ["z3adapter/dsl/expressions.py", "z3adapter/solvers/z3_solver.py", "z3adapter/verification/verifier.py"], "used_names": ["Z3Solver"], "enclosing_function": "test_verify_conditions_unsat", "extracted_code": "# Source: z3adapter/solvers/z3_solver.py\nclass Z3Solver(AbstractSolver):\n    \"\"\"Z3 solver implementation.\"\"\"\n\n    def __init__(self) -> None:\n        self.solver = Solver()\n\n    def add(self, constraint: Any) -> None:\n        \"\"\"Add a constraint to the Z3 solver.\"\"\"\n        self.solver.add(constraint)\n\n    def check(self, condition: Any = None) -> Any:\n        \"\"\"Check satisfiability with optional condition.\"\"\"\n        if condition is not None:\n            return self.solver.check(condition)\n        return self.solver.check()\n\n    def model(self) -> Any:\n        \"\"\"Return the satisfying model.\"\"\"\n        return self.solver.model()\n\n    def set(self, param: str, value: Any) -> None:\n        \"\"\"Set Z3 solver parameter.\"\"\"\n        self.solver.set(param, value)", "n_imports_parsed": 6, "n_files_resolved": 3, "n_chars_extracted": 767}, "tests/unit/test_security_validator.py::25": {"resolved_imports": ["z3adapter/security/validator.py"], "used_names": ["ExpressionValidator", "ast"], "enclosing_function": "test_check_safe_ast_blocks_dunder_attributes", "extracted_code": "# Source: z3adapter/security/validator.py\nclass ExpressionValidator:\n    \"\"\"Validates expressions for security issues before evaluation.\"\"\"\n\n    @staticmethod\n    def check_safe_ast(node: ast.AST, expr_str: str) -> None:\n        \"\"\"Check AST for dangerous constructs.\n\n        Args:\n            node: AST node to check\n            expr_str: Original expression string for error messages\n\n        Raises:\n            ValueError: If dangerous construct found\n        \"\"\"\n        for n in ast.walk(node):\n            # Block attribute access to dunder methods\n            if isinstance(n, ast.Attribute):\n                if n.attr.startswith(\"__\") and n.attr.endswith(\"__\"):\n                    raise ValueError(\n                        f\"Access to dunder attribute '{n.attr}' not allowed in '{expr_str}'\"\n                    )\n            # Block imports\n            elif isinstance(n, (ast.Import, ast.ImportFrom)):\n                raise ValueError(f\"Import statements not allowed in '{expr_str}'\")\n            # Block function/class definitions\n            elif isinstance(n, (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef)):\n                raise ValueError(f\"Function/class definitions not allowed in '{expr_str}'\")\n            # Block exec/eval\n            elif isinstance(n, ast.Call):\n                if isinstance(n.func, ast.Name) and n.func.id in (\n                    \"eval\",\n                    \"exec\",\n                    \"compile\",\n                    \"__import__\",\n                ):\n                    raise ValueError(f\"Call to '{n.func.id}' not allowed in '{expr_str}'\")\n\n    @staticmethod\n    def safe_eval(expr_str: str, safe_globals: dict[str, Any], context: dict[str, Any]) -> Any:\n        \"\"\"Safely evaluate expression string with restricted globals.\n\n        Args:\n            expr_str: Expression string to evaluate\n            safe_globals: Safe global functions/operators\n            context: Local context dictionary\n\n        Returns:\n            Evaluated expression\n\n        Raises:\n            ValueError: If expression cannot be evaluated safely\n        \"\"\"\n        try:\n            # Parse to AST and check for dangerous constructs\n            tree = ast.parse(expr_str, mode=\"eval\")\n            ExpressionValidator.check_safe_ast(tree, expr_str)\n\n            # Compile and evaluate with restricted builtins\n            code = compile(tree, \"<string>\", \"eval\")\n            return eval(code, {\"__builtins__\": {}}, {**safe_globals, **context})\n        except SyntaxError as e:\n            raise ValueError(f\"Syntax error in expression '{expr_str}': {e}\") from e\n        except NameError as e:\n            raise ValueError(f\"Undefined name in expression '{expr_str}': {e}\") from e\n        except Exception as e:\n            raise ValueError(f\"Error evaluating expression '{expr_str}': {e}\") from e", "n_imports_parsed": 3, "n_files_resolved": 1, "n_chars_extracted": 2832}, "tests/unit/test_security_validator.py::23": {"resolved_imports": ["z3adapter/security/validator.py"], "used_names": ["ExpressionValidator", "ast"], "enclosing_function": "test_check_safe_ast_blocks_dunder_attributes", "extracted_code": "# Source: z3adapter/security/validator.py\nclass ExpressionValidator:\n    \"\"\"Validates expressions for security issues before evaluation.\"\"\"\n\n    @staticmethod\n    def check_safe_ast(node: ast.AST, expr_str: str) -> None:\n        \"\"\"Check AST for dangerous constructs.\n\n        Args:\n            node: AST node to check\n            expr_str: Original expression string for error messages\n\n        Raises:\n            ValueError: If dangerous construct found\n        \"\"\"\n        for n in ast.walk(node):\n            # Block attribute access to dunder methods\n            if isinstance(n, ast.Attribute):\n                if n.attr.startswith(\"__\") and n.attr.endswith(\"__\"):\n                    raise ValueError(\n                        f\"Access to dunder attribute '{n.attr}' not allowed in '{expr_str}'\"\n                    )\n            # Block imports\n            elif isinstance(n, (ast.Import, ast.ImportFrom)):\n                raise ValueError(f\"Import statements not allowed in '{expr_str}'\")\n            # Block function/class definitions\n            elif isinstance(n, (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef)):\n                raise ValueError(f\"Function/class definitions not allowed in '{expr_str}'\")\n            # Block exec/eval\n            elif isinstance(n, ast.Call):\n                if isinstance(n.func, ast.Name) and n.func.id in (\n                    \"eval\",\n                    \"exec\",\n                    \"compile\",\n                    \"__import__\",\n                ):\n                    raise ValueError(f\"Call to '{n.func.id}' not allowed in '{expr_str}'\")\n\n    @staticmethod\n    def safe_eval(expr_str: str, safe_globals: dict[str, Any], context: dict[str, Any]) -> Any:\n        \"\"\"Safely evaluate expression string with restricted globals.\n\n        Args:\n            expr_str: Expression string to evaluate\n            safe_globals: Safe global functions/operators\n            context: Local context dictionary\n\n        Returns:\n            Evaluated expression\n\n        Raises:\n            ValueError: If expression cannot be evaluated safely\n        \"\"\"\n        try:\n            # Parse to AST and check for dangerous constructs\n            tree = ast.parse(expr_str, mode=\"eval\")\n            ExpressionValidator.check_safe_ast(tree, expr_str)\n\n            # Compile and evaluate with restricted builtins\n            code = compile(tree, \"<string>\", \"eval\")\n            return eval(code, {\"__builtins__\": {}}, {**safe_globals, **context})\n        except SyntaxError as e:\n            raise ValueError(f\"Syntax error in expression '{expr_str}': {e}\") from e\n        except NameError as e:\n            raise ValueError(f\"Undefined name in expression '{expr_str}': {e}\") from e\n        except Exception as e:\n            raise ValueError(f\"Error evaluating expression '{expr_str}': {e}\") from e", "n_imports_parsed": 3, "n_files_resolved": 1, "n_chars_extracted": 2832}, "tests/unit/test_expression_parser.py::25": {"resolved_imports": ["z3adapter/dsl/expressions.py"], "used_names": [], "enclosing_function": "test_parse_simple_arithmetic", "extracted_code": "", "n_imports_parsed": 4, "n_files_resolved": 1, "n_chars_extracted": 0}, "tests/unit/test_optimizer.py::96": {"resolved_imports": ["z3adapter/dsl/expressions.py", "z3adapter/optimization/optimizer.py"], "used_names": [], "enclosing_function": "test_optimize_invalid_constraint_syntax", "extracted_code": "", "n_imports_parsed": 5, "n_files_resolved": 2, "n_chars_extracted": 0}, "tests/unit/test_sort_manager.py::24": {"resolved_imports": ["z3adapter/dsl/sorts.py"], "used_names": ["BoolSort", "IntSort", "RealSort"], "enclosing_function": "test_builtin_sorts_initialized", "extracted_code": "", "n_imports_parsed": 3, "n_files_resolved": 1, "n_chars_extracted": 0}, "tests/unit/test_expression_parser.py::79": {"resolved_imports": ["z3adapter/dsl/expressions.py"], "used_names": ["Const", "IntSort"], "enclosing_function": "test_quantified_var_shadows_constant_warning", "extracted_code": "", "n_imports_parsed": 4, "n_files_resolved": 1, "n_chars_extracted": 0}, "tests/unit/test_optimizer.py::87": {"resolved_imports": ["z3adapter/dsl/expressions.py", "z3adapter/optimization/optimizer.py"], "used_names": [], "enclosing_function": "test_optimize_unknown_objective_type", "extracted_code": "", "n_imports_parsed": 5, "n_files_resolved": 2, "n_chars_extracted": 0}, "tests/integration/test_interpreter.py::89": {"resolved_imports": ["z3adapter/interpreter.py"], "used_names": ["Z3JSONInterpreter", "json", "os", "tempfile"], "enclosing_function": "test_invalid_constants_section_structure", "extracted_code": "# Source: z3adapter/interpreter.py\nclass Z3JSONInterpreter:\n    \"\"\"Interpreter for Z3 DSL defined in JSON format.\"\"\"\n\n    # Default timeout values in milliseconds\n    DEFAULT_VERIFY_TIMEOUT = 10000\n    DEFAULT_OPTIMIZE_TIMEOUT = 100000\n\n    def __init__(\n        self,\n        json_file: str,\n        solver: AbstractSolver | None = None,\n        verify_timeout: int = DEFAULT_VERIFY_TIMEOUT,\n        optimize_timeout: int = DEFAULT_OPTIMIZE_TIMEOUT,\n    ):\n        \"\"\"Initialize the Z3 JSON interpreter.\n\n        Args:\n            json_file: Path to JSON configuration file\n            solver: Optional solver instance (defaults to Z3Solver)\n            verify_timeout: Timeout for verification in milliseconds\n            optimize_timeout: Timeout for optimization in milliseconds\n        \"\"\"\n        self.json_file = json_file\n        self.verify_timeout = verify_timeout\n        self.optimize_timeout = optimize_timeout\n        self.config = self.load_and_validate_json(json_file)\n        self.solver = solver if solver else Z3Solver()\n\n        # Initialize components\n        self.sort_manager = SortManager()\n        self.expression_parser: ExpressionParser | None = None\n        self.verifier: Verifier | None = None\n        self.optimizer_runner: OptimizerRunner | None = None\n\n    def load_and_validate_json(self, json_file: str) -> dict[str, Any]:\n        \"\"\"Load and validate JSON configuration file.\n\n        Args:\n            json_file: Path to JSON file\n\n        Returns:\n            Validated configuration dictionary\n\n        Raises:\n            FileNotFoundError: If JSON file doesn't exist\n            json.JSONDecodeError: If JSON is malformed\n            ValueError: If required sections are invalid\n        \"\"\"\n        try:\n            with open(json_file) as file:\n                config = json.load(file)\n        except FileNotFoundError:\n            logger.error(f\"JSON file not found: {json_file}\")\n            raise\n        except json.JSONDecodeError as e:\n            logger.error(f\"Invalid JSON in {json_file}: {e}\")\n            raise\n\n        # Initialize missing sections with appropriate defaults\n        default_sections: dict[str, Any] = {\n            \"sorts\": [],\n            \"functions\": [],\n            \"constants\": {},\n            \"knowledge_base\": [],\n            \"rules\": [],\n            \"verifications\": [],\n            \"actions\": [],\n            \"variables\": [],\n        }\n\n        for section, default in default_sections.items():\n            if section not in config:\n                config[section] = default\n                logger.debug(f\"Section '{section}' not found, using default: {default}\")\n\n        # Validate structure\n        if not isinstance(config.get(\"constants\"), dict):\n            config[\"constants\"] = {}\n            logger.warning(\"'constants' section should be a dictionary, resetting to empty dict\")\n\n        return config\n\n    def perform_actions(self) -> None:\n        \"\"\"Execute actions specified in configuration.\n\n        Actions are method names to be called on this interpreter instance.\n        \"\"\"\n        for action in self.config[\"actions\"]:\n            if hasattr(self, action):\n                try:\n                    logger.info(f\"Executing action: {action}\")\n                    getattr(self, action)()\n                except Exception as e:\n                    logger.error(f\"Error executing action '{action}': {e}\")\n                    raise\n            else:\n                logger.warning(f\"Unknown action: {action}\")\n\n    def verify_conditions(self) -> None:\n        \"\"\"Verify all defined verification conditions.\"\"\"\n        if self.verifier:\n            self.verifier.verify_conditions(self.solver, self.verify_timeout)\n\n    def get_verification_counts(self) -> tuple[int, int]:\n        \"\"\"Get SAT and UNSAT counts from verification results.\n\n        Returns:\n            Tuple of (sat_count, unsat_count)\n        \"\"\"\n        if self.verifier:\n            return (self.verifier.sat_count, self.verifier.unsat_count)\n        return (0, 0)\n\n    def optimize(self) -> None:\n        \"\"\"Run optimization if configured.\"\"\"\n        if self.optimizer_runner and \"optimization\" in self.config:\n            self.optimizer_runner.optimize(self.config[\"optimization\"], self.optimize_timeout)\n\n    def run(self) -> None:\n        \"\"\"Execute the full interpretation pipeline.\n\n        Steps:\n        1. Create sorts\n        2. Create functions\n        3. Create constants\n        4. Create variables\n        5. Add knowledge base\n        6. Add rules\n        7. Add verifications\n        8. Perform configured actions\n\n        Raises:\n            Various exceptions if any step fails\n        \"\"\"\n        try:\n            logger.info(f\"Starting interpretation of {self.json_file}\")\n\n            # Step 1: Create sorts\n            self.sort_manager.create_sorts(self.config[\"sorts\"])\n\n            # Step 2: Create functions\n            functions = self.sort_manager.create_functions(self.config[\"functions\"])\n\n            # Step 3: Create constants\n            self.sort_manager.create_constants(self.config[\"constants\"])\n\n            # Step 4: Create variables\n            variables = self.sort_manager.create_variables(self.config.get(\"variables\", []))\n\n            # Initialize expression parser with all symbols\n            self.expression_parser = ExpressionParser(\n                functions=functions, constants=self.sort_manager.constants, variables=variables\n            )\n\n            # Mark that all symbols have been loaded\n            self.expression_parser.mark_symbols_loaded()\n\n            # Step 5: Add knowledge base\n            self.expression_parser.add_knowledge_base(self.solver, self.config[\"knowledge_base\"])\n\n            # Step 6: Add rules\n            self.expression_parser.add_rules(\n                self.solver, self.config[\"rules\"], self.sort_manager.sorts\n            )\n\n            # Step 7: Initialize verifier and add verifications\n            self.verifier = Verifier(self.expression_parser, self.sort_manager.sorts)\n            self.verifier.add_verifications(self.config[\"verifications\"])\n\n            # Initialize optimizer runner\n            self.optimizer_runner = OptimizerRunner(\n                self.expression_parser, self.sort_manager.sorts, ExpressionParser.Z3_OPERATORS\n            )\n\n            # Step 8: Perform actions\n            self.perform_actions()\n\n            logger.info(\"Interpretation completed successfully\")\n        except Exception as e:\n            logger.error(f\"Interpretation failed: {e}\")\n            raise", "n_imports_parsed": 5, "n_files_resolved": 1, "n_chars_extracted": 6545}, "tests/unit/test_expression_parser.py::86": {"resolved_imports": ["z3adapter/dsl/expressions.py"], "used_names": [], "enclosing_function": "test_parse_expression_with_invalid_syntax", "extracted_code": "", "n_imports_parsed": 4, "n_files_resolved": 1, "n_chars_extracted": 0}, "tests/integration/test_interpreter.py::61": {"resolved_imports": ["z3adapter/interpreter.py"], "used_names": ["Z3JSONInterpreter"], "enclosing_function": "test_custom_timeouts", "extracted_code": "# Source: z3adapter/interpreter.py\nclass Z3JSONInterpreter:\n    \"\"\"Interpreter for Z3 DSL defined in JSON format.\"\"\"\n\n    # Default timeout values in milliseconds\n    DEFAULT_VERIFY_TIMEOUT = 10000\n    DEFAULT_OPTIMIZE_TIMEOUT = 100000\n\n    def __init__(\n        self,\n        json_file: str,\n        solver: AbstractSolver | None = None,\n        verify_timeout: int = DEFAULT_VERIFY_TIMEOUT,\n        optimize_timeout: int = DEFAULT_OPTIMIZE_TIMEOUT,\n    ):\n        \"\"\"Initialize the Z3 JSON interpreter.\n\n        Args:\n            json_file: Path to JSON configuration file\n            solver: Optional solver instance (defaults to Z3Solver)\n            verify_timeout: Timeout for verification in milliseconds\n            optimize_timeout: Timeout for optimization in milliseconds\n        \"\"\"\n        self.json_file = json_file\n        self.verify_timeout = verify_timeout\n        self.optimize_timeout = optimize_timeout\n        self.config = self.load_and_validate_json(json_file)\n        self.solver = solver if solver else Z3Solver()\n\n        # Initialize components\n        self.sort_manager = SortManager()\n        self.expression_parser: ExpressionParser | None = None\n        self.verifier: Verifier | None = None\n        self.optimizer_runner: OptimizerRunner | None = None\n\n    def load_and_validate_json(self, json_file: str) -> dict[str, Any]:\n        \"\"\"Load and validate JSON configuration file.\n\n        Args:\n            json_file: Path to JSON file\n\n        Returns:\n            Validated configuration dictionary\n\n        Raises:\n            FileNotFoundError: If JSON file doesn't exist\n            json.JSONDecodeError: If JSON is malformed\n            ValueError: If required sections are invalid\n        \"\"\"\n        try:\n            with open(json_file) as file:\n                config = json.load(file)\n        except FileNotFoundError:\n            logger.error(f\"JSON file not found: {json_file}\")\n            raise\n        except json.JSONDecodeError as e:\n            logger.error(f\"Invalid JSON in {json_file}: {e}\")\n            raise\n\n        # Initialize missing sections with appropriate defaults\n        default_sections: dict[str, Any] = {\n            \"sorts\": [],\n            \"functions\": [],\n            \"constants\": {},\n            \"knowledge_base\": [],\n            \"rules\": [],\n            \"verifications\": [],\n            \"actions\": [],\n            \"variables\": [],\n        }\n\n        for section, default in default_sections.items():\n            if section not in config:\n                config[section] = default\n                logger.debug(f\"Section '{section}' not found, using default: {default}\")\n\n        # Validate structure\n        if not isinstance(config.get(\"constants\"), dict):\n            config[\"constants\"] = {}\n            logger.warning(\"'constants' section should be a dictionary, resetting to empty dict\")\n\n        return config\n\n    def perform_actions(self) -> None:\n        \"\"\"Execute actions specified in configuration.\n\n        Actions are method names to be called on this interpreter instance.\n        \"\"\"\n        for action in self.config[\"actions\"]:\n            if hasattr(self, action):\n                try:\n                    logger.info(f\"Executing action: {action}\")\n                    getattr(self, action)()\n                except Exception as e:\n                    logger.error(f\"Error executing action '{action}': {e}\")\n                    raise\n            else:\n                logger.warning(f\"Unknown action: {action}\")\n\n    def verify_conditions(self) -> None:\n        \"\"\"Verify all defined verification conditions.\"\"\"\n        if self.verifier:\n            self.verifier.verify_conditions(self.solver, self.verify_timeout)\n\n    def get_verification_counts(self) -> tuple[int, int]:\n        \"\"\"Get SAT and UNSAT counts from verification results.\n\n        Returns:\n            Tuple of (sat_count, unsat_count)\n        \"\"\"\n        if self.verifier:\n            return (self.verifier.sat_count, self.verifier.unsat_count)\n        return (0, 0)\n\n    def optimize(self) -> None:\n        \"\"\"Run optimization if configured.\"\"\"\n        if self.optimizer_runner and \"optimization\" in self.config:\n            self.optimizer_runner.optimize(self.config[\"optimization\"], self.optimize_timeout)\n\n    def run(self) -> None:\n        \"\"\"Execute the full interpretation pipeline.\n\n        Steps:\n        1. Create sorts\n        2. Create functions\n        3. Create constants\n        4. Create variables\n        5. Add knowledge base\n        6. Add rules\n        7. Add verifications\n        8. Perform configured actions\n\n        Raises:\n            Various exceptions if any step fails\n        \"\"\"\n        try:\n            logger.info(f\"Starting interpretation of {self.json_file}\")\n\n            # Step 1: Create sorts\n            self.sort_manager.create_sorts(self.config[\"sorts\"])\n\n            # Step 2: Create functions\n            functions = self.sort_manager.create_functions(self.config[\"functions\"])\n\n            # Step 3: Create constants\n            self.sort_manager.create_constants(self.config[\"constants\"])\n\n            # Step 4: Create variables\n            variables = self.sort_manager.create_variables(self.config.get(\"variables\", []))\n\n            # Initialize expression parser with all symbols\n            self.expression_parser = ExpressionParser(\n                functions=functions, constants=self.sort_manager.constants, variables=variables\n            )\n\n            # Mark that all symbols have been loaded\n            self.expression_parser.mark_symbols_loaded()\n\n            # Step 5: Add knowledge base\n            self.expression_parser.add_knowledge_base(self.solver, self.config[\"knowledge_base\"])\n\n            # Step 6: Add rules\n            self.expression_parser.add_rules(\n                self.solver, self.config[\"rules\"], self.sort_manager.sorts\n            )\n\n            # Step 7: Initialize verifier and add verifications\n            self.verifier = Verifier(self.expression_parser, self.sort_manager.sorts)\n            self.verifier.add_verifications(self.config[\"verifications\"])\n\n            # Initialize optimizer runner\n            self.optimizer_runner = OptimizerRunner(\n                self.expression_parser, self.sort_manager.sorts, ExpressionParser.Z3_OPERATORS\n            )\n\n            # Step 8: Perform actions\n            self.perform_actions()\n\n            logger.info(\"Interpretation completed successfully\")\n        except Exception as e:\n            logger.error(f\"Interpretation failed: {e}\")\n            raise", "n_imports_parsed": 5, "n_files_resolved": 1, "n_chars_extracted": 6545}, "tests/unit/test_security_validator.py::78": {"resolved_imports": ["z3adapter/security/validator.py"], "used_names": ["ExpressionValidator"], "enclosing_function": "test_safe_eval_evaluates_simple_expression", "extracted_code": "# Source: z3adapter/security/validator.py\nclass ExpressionValidator:\n    \"\"\"Validates expressions for security issues before evaluation.\"\"\"\n\n    @staticmethod\n    def check_safe_ast(node: ast.AST, expr_str: str) -> None:\n        \"\"\"Check AST for dangerous constructs.\n\n        Args:\n            node: AST node to check\n            expr_str: Original expression string for error messages\n\n        Raises:\n            ValueError: If dangerous construct found\n        \"\"\"\n        for n in ast.walk(node):\n            # Block attribute access to dunder methods\n            if isinstance(n, ast.Attribute):\n                if n.attr.startswith(\"__\") and n.attr.endswith(\"__\"):\n                    raise ValueError(\n                        f\"Access to dunder attribute '{n.attr}' not allowed in '{expr_str}'\"\n                    )\n            # Block imports\n            elif isinstance(n, (ast.Import, ast.ImportFrom)):\n                raise ValueError(f\"Import statements not allowed in '{expr_str}'\")\n            # Block function/class definitions\n            elif isinstance(n, (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef)):\n                raise ValueError(f\"Function/class definitions not allowed in '{expr_str}'\")\n            # Block exec/eval\n            elif isinstance(n, ast.Call):\n                if isinstance(n.func, ast.Name) and n.func.id in (\n                    \"eval\",\n                    \"exec\",\n                    \"compile\",\n                    \"__import__\",\n                ):\n                    raise ValueError(f\"Call to '{n.func.id}' not allowed in '{expr_str}'\")\n\n    @staticmethod\n    def safe_eval(expr_str: str, safe_globals: dict[str, Any], context: dict[str, Any]) -> Any:\n        \"\"\"Safely evaluate expression string with restricted globals.\n\n        Args:\n            expr_str: Expression string to evaluate\n            safe_globals: Safe global functions/operators\n            context: Local context dictionary\n\n        Returns:\n            Evaluated expression\n\n        Raises:\n            ValueError: If expression cannot be evaluated safely\n        \"\"\"\n        try:\n            # Parse to AST and check for dangerous constructs\n            tree = ast.parse(expr_str, mode=\"eval\")\n            ExpressionValidator.check_safe_ast(tree, expr_str)\n\n            # Compile and evaluate with restricted builtins\n            code = compile(tree, \"<string>\", \"eval\")\n            return eval(code, {\"__builtins__\": {}}, {**safe_globals, **context})\n        except SyntaxError as e:\n            raise ValueError(f\"Syntax error in expression '{expr_str}': {e}\") from e\n        except NameError as e:\n            raise ValueError(f\"Undefined name in expression '{expr_str}': {e}\") from e\n        except Exception as e:\n            raise ValueError(f\"Error evaluating expression '{expr_str}': {e}\") from e", "n_imports_parsed": 3, "n_files_resolved": 1, "n_chars_extracted": 2832}, "tests/integration/test_bug_fixes.py::63": {"resolved_imports": ["z3adapter/dsl/expressions.py", "z3adapter/dsl/sorts.py", "z3adapter/interpreter.py", "z3adapter/security/validator.py"], "used_names": ["ExpressionValidator", "ast"], "enclosing_function": "test_bug5_security_sandbox_ast_based", "extracted_code": "# Source: z3adapter/security/validator.py\nclass ExpressionValidator:\n    \"\"\"Validates expressions for security issues before evaluation.\"\"\"\n\n    @staticmethod\n    def check_safe_ast(node: ast.AST, expr_str: str) -> None:\n        \"\"\"Check AST for dangerous constructs.\n\n        Args:\n            node: AST node to check\n            expr_str: Original expression string for error messages\n\n        Raises:\n            ValueError: If dangerous construct found\n        \"\"\"\n        for n in ast.walk(node):\n            # Block attribute access to dunder methods\n            if isinstance(n, ast.Attribute):\n                if n.attr.startswith(\"__\") and n.attr.endswith(\"__\"):\n                    raise ValueError(\n                        f\"Access to dunder attribute '{n.attr}' not allowed in '{expr_str}'\"\n                    )\n            # Block imports\n            elif isinstance(n, (ast.Import, ast.ImportFrom)):\n                raise ValueError(f\"Import statements not allowed in '{expr_str}'\")\n            # Block function/class definitions\n            elif isinstance(n, (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef)):\n                raise ValueError(f\"Function/class definitions not allowed in '{expr_str}'\")\n            # Block exec/eval\n            elif isinstance(n, ast.Call):\n                if isinstance(n.func, ast.Name) and n.func.id in (\n                    \"eval\",\n                    \"exec\",\n                    \"compile\",\n                    \"__import__\",\n                ):\n                    raise ValueError(f\"Call to '{n.func.id}' not allowed in '{expr_str}'\")\n\n    @staticmethod\n    def safe_eval(expr_str: str, safe_globals: dict[str, Any], context: dict[str, Any]) -> Any:\n        \"\"\"Safely evaluate expression string with restricted globals.\n\n        Args:\n            expr_str: Expression string to evaluate\n            safe_globals: Safe global functions/operators\n            context: Local context dictionary\n\n        Returns:\n            Evaluated expression\n\n        Raises:\n            ValueError: If expression cannot be evaluated safely\n        \"\"\"\n        try:\n            # Parse to AST and check for dangerous constructs\n            tree = ast.parse(expr_str, mode=\"eval\")\n            ExpressionValidator.check_safe_ast(tree, expr_str)\n\n            # Compile and evaluate with restricted builtins\n            code = compile(tree, \"<string>\", \"eval\")\n            return eval(code, {\"__builtins__\": {}}, {**safe_globals, **context})\n        except SyntaxError as e:\n            raise ValueError(f\"Syntax error in expression '{expr_str}': {e}\") from e\n        except NameError as e:\n            raise ValueError(f\"Undefined name in expression '{expr_str}': {e}\") from e\n        except Exception as e:\n            raise ValueError(f\"Error evaluating expression '{expr_str}': {e}\") from e", "n_imports_parsed": 9, "n_files_resolved": 4, "n_chars_extracted": 2832}}}