codeanalyzer-python 0.2.0__py3-none-any.whl → 0.3.0__py3-none-any.whl

codeanalyzer/semantic_analysis/codeql/codeql_analysis.py

@@ -1,382 +0,0 @@
-################################################################################
-# Copyright IBM Corporation 2025
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#       http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-################################################################################
-
-"""CodeQL module for analyzing Python code using CodeQL.
-
-This module provides functionality to create and manage CodeQL databases
-for Python projects and execute queries against them.
-"""
-
-from collections import Counter
-from pathlib import Path
-from typing import Any, Dict, Iterator, List, Tuple, Union
-
-from pandas import DataFrame
-
-from codeanalyzer.schema.py_schema import PyCallEdge, PyModule
-from codeanalyzer.semantic_analysis.call_graph import iter_callables_in_symbol_table
-from codeanalyzer.semantic_analysis.codeql.codeql_query_runner import CodeQLQueryRunner
-from codeanalyzer.utils import logger
-
-
-class _CallableResolver:
-    """Maps a CodeQL endpoint ``(file, start_line, name, arity)`` to a Jedi
-    ``PyCallable``.
-
-    Resolution ladder:
-      1. exact ``(abs_path, start_line)`` — the precise join;
-      2. on miss, candidates sharing ``(abs_path, short_name)``: a single
-         candidate is taken directly; otherwise prefer those whose
-         parameter count equals the CodeQL positional arity, then the
-         nearest ``start_line``;
-      3. no name match -> ``None`` (caller row skipped / callee becomes
-         a ghost node).
-
-    Step 2 recovers edges the ``(file, line)`` join silently drops when
-    CodeQL and Jedi disagree on a definition's start line (e.g. decorator
-    handling). Jedi's ``parameters`` counts every declared slot (incl.
-    ``*args``/``**kwargs``/keyword-only) whereas CodeQL's arity is
-    positional only, so the arity filter is exact for plain signatures
-    and otherwise yields to the nearest-line tiebreak.
-    """
-
-    def __init__(self) -> None:
-        self._by_loc: Dict[Tuple[str, int], Any] = {}
-        self._by_name: Dict[Tuple[str, str], List[Any]] = {}
-
-    @staticmethod
-    def _abs(path: str) -> str:
-        try:
-            return str(Path(path).resolve())
-        except (OSError, RuntimeError):
-            return path
-
-    @classmethod
-    def from_symbol_table(
-        cls, symbol_table: Dict[str, PyModule]
-    ) -> "_CallableResolver":
-        resolver = cls()
-        for c in iter_callables_in_symbol_table(symbol_table):
-            abs_path = cls._abs(c.path)
-            resolver._by_loc[(abs_path, c.start_line)] = c
-            resolver._by_name.setdefault((abs_path, c.name), []).append(c)
-        return resolver
-
-    def resolve(
-        self, file: str, start_line: int, name: str, arity: int
-    ) -> Any:
-        exact = self._by_loc.get((file, start_line))
-        if exact is not None:
-            return exact
-        if not name:
-            return None
-        candidates = self._by_name.get((file, name))
-        if not candidates:
-            return None
-        if len(candidates) == 1:
-            return candidates[0]
-        arity_matched = [c for c in candidates if len(c.parameters) == arity]
-        pool = arity_matched or candidates
-        return min(pool, key=lambda c: abs(c.start_line - start_line))
-
-
-class CodeQL:
-    """A class for building the application view of a Python application using CodeQL.
-
-    Args:
-        project_dir (str or Path): The path to the root of the Python project.
-
-    Attributes:
-        db_path (Path): The path to the CodeQL database.
-        temp_db (TemporaryDirectory or None): The temporary directory object if a temporary database was created.
-    """
-
-    def __init__(
-        self,
-        project_dir: Union[str, Path],
-        db_path: Path,
-        codeql_bin: Union[str, Path, None] = None,
-        codeql_packs_dir: Union[str, Path, None] = None,
-    ) -> None:
-        self.project_dir = project_dir
-        self.db_path = db_path
-        self.codeql_bin = codeql_bin
-        self.codeql_packs_dir = codeql_packs_dir
-        self._cached_df: "DataFrame | None" = None
-
-    def _query_call_edges(self) -> DataFrame:
-        """Runs the CodeQL query that emits one row per resolved call site.
-
-        The query is written against CodeQL's Python library (``import python``).
-        It returns physical location handles for both endpoints so the
-        downstream post-processor can join into Jedi's existing
-        ``PyCallable.signature`` space via ``(file_path, start_line)`` —
-        no signature normalization required.
-
-        Filters:
-          * Caller must be a ``Function`` (skip module-level / class-body
-            calls — they have no ``PyCallable`` to anchor to).
-          * Callee may resolve to anything (in-source or library stub);
-            non-application callees become **ghost** nodes downstream so
-            RPC / third-party / framework edges are preserved.
-
-        Returns:
-            DataFrame: one row per resolved (caller, callee, call-site)
-            triple. Duplicate ``(caller_file, caller_start_line,
-            callee_file, callee_start_line)`` tuples represent multiple
-            call sites in the same caller targeting the same callee and
-            are coalesced into a single ``PyCallEdge`` (weight = count)
-            by the post-processor.
-        """
-        query = [
-            "/**",
-            " * @name Python call-graph edges",
-            " * @description One row per resolved call site: caller, callee,",
-            " *              and the call-expression location.",
-            " * @kind table",
-            " * @id py/codeanalyzer/call-graph-edges",
-            " */",
-            "import python",
-            # ``FunctionValue`` / ``ClassValue`` / the ``pointsTo`` predicate
-            # live in ObjectAPI, which ``import python`` only brings in as a
-            # private import — they aren't re-exported. Pull them in
-            # explicitly.
-            "import semmle.python.objects.ObjectAPI",
-            "",
-            # ``Value.getACall()`` is the modern call-resolution API in
-            # codeql/python-all 7.x — it returns the ``CallNode`` (CFG)
-            # whose target was resolved to that ``Value``. Cleaner than
-            # poking at ``pointsTo`` directly.
-            # ``callee`` is bound to the FunctionValue's scope so the
-            # endpoint emits the same Function-level facts (name, arity,
-            # location) the post-processor needs for the name+arity
-            # fallback when the (file, start_line) join misses.
-            "from CallNode call, Function caller, FunctionValue calleeVal, Function callee",
-            "where",
-            "  call.getScope() = caller and",
-            "  callee = calleeVal.getScope() and",
-            "  (",
-            # Direct function / bound-method call:  foo()  or  obj.foo()
-            "    call = calleeVal.getACall()",
-            "    or",
-            # Constructor call:  A(...)  resolves to a ClassValue; the actual
-            # callee is the class's __init__ (via MRO lookup so subclasses
-            # without an explicit __init__ still resolve to the inherited one).
-            "    exists(ClassValue clsVal |",
-            "      call = clsVal.getACall() and",
-            '      clsVal.lookup("__init__") = calleeVal',
-            "    )",
-            "  )",
-            "select",
-            # --- Caller endpoint --- (joins to PyCallable: exact by
-            #     (file, start_line), else by (file, name) + arity)
-            "  caller.getLocation().getFile().getAbsolutePath(),",
-            "  caller.getLocation().getStartLine(),",
-            "  caller.getQualifiedName(),",
-            "  caller.getName(),",
-            "  count(caller.getArg(_)),",
-            # --- Callee endpoint --- (file/line may live in a library stub;
-            #     post-processor classifies as in-source or ghost)
-            "  callee.getLocation().getFile().getAbsolutePath(),",
-            "  callee.getLocation().getStartLine(),",
-            "  calleeVal.getQualifiedName(),",
-            "  callee.getName(),",
-            "  count(callee.getArg(_)),",
-            # --- Call-site location --- (for PyCallsite augmentation)
-            "  call.getLocation().getStartLine(),",
-            "  call.getLocation().getStartColumn(),",
-            "  call.getLocation().getEndLine(),",
-            "  call.getLocation().getEndColumn()",
-            # ``is_constructor`` is derived in the post-processor by
-            # checking whether ``callee_qname`` ends in ``.__init__``;
-            # avoids QL's restrictive ``if-then-else`` typing here.
-        ]
-        if self._cached_df is not None:
-            return self._cached_df
-
-        query_string = "\n".join(query)
-
-        with CodeQLQueryRunner(
-            self.db_path,
-            codeql_bin=self.codeql_bin,
-            codeql_packs_dir=self.codeql_packs_dir,
-        ) as runner:
-            df: DataFrame = runner.execute(
-                query_string,
-                column_names=[
-                    "caller_file",
-                    "caller_start_line",
-                    "caller_qname",
-                    "caller_name",
-                    "caller_arity",
-                    "callee_file",
-                    "callee_start_line",
-                    "callee_qname",
-                    "callee_name",
-                    "callee_arity",
-                    "call_start_line",
-                    "call_start_column",
-                    "call_end_line",
-                    "call_end_column",
-                ],
-            )
-        self._cached_df = df
-        return df
-
-    @staticmethod
-    def _build_callable_resolver(
-        symbol_table: Dict[str, PyModule],
-    ) -> _CallableResolver:
-        """Build the endpoint -> ``PyCallable`` resolver from Jedi.
-
-        Paths are resolved so they match CodeQL's ``getAbsolutePath()``
-        regardless of symlinks or the current working directory.
-        """
-        return _CallableResolver.from_symbol_table(symbol_table)
-
-    def _iter_resolved_rows(
-        self, symbol_table: Dict[str, PyModule]
-    ) -> "Iterator[Tuple[str, str, Any]]":
-        """Yield ``(source_sig, target_sig, row)`` for every CodeQL row.
-
-        Rows whose caller can't be matched to a ``PyCallable`` in the
-        symbol table are skipped. Callee misses fall back to
-        ``row.callee_qname`` (ghost). Used by both edge construction and
-        call-site augmentation so a single CodeQL query feeds both.
-        """
-        df = self._query_call_edges()
-        if df.empty:
-            return
-        resolver = self._build_callable_resolver(symbol_table)
-
-        skipped_unknown_caller = 0
-        ghost_callees = 0
-        for row in df.itertuples(index=False):
-            caller = resolver.resolve(
-                row.caller_file,
-                int(row.caller_start_line),
-                row.caller_name,
-                int(row.caller_arity),
-            )
-            if caller is None:
-                skipped_unknown_caller += 1
-                continue
-
-            callee = resolver.resolve(
-                row.callee_file,
-                int(row.callee_start_line),
-                row.callee_name,
-                int(row.callee_arity),
-            )
-            if callee is not None:
-                target_sig = callee.signature
-            else:
-                target_sig = row.callee_qname
-                ghost_callees += 1
-
-            yield caller.signature, target_sig, row
-
-        if skipped_unknown_caller:
-            logger.debug(
-                f"CodeQL: skipped {skipped_unknown_caller} rows whose caller "
-                f"was not in Jedi's symbol table."
-            )
-        if ghost_callees:
-            logger.debug(
-                f"CodeQL: {ghost_callees} rows resolved to ghost (external) callees."
-            )
-
-    def build_call_graph_edges(
-        self, symbol_table: Dict[str, PyModule]
-    ) -> List[PyCallEdge]:
-        """Run the CodeQL query and turn each row into a ``PyCallEdge``.
-
-        Edges are coalesced on ``(source, target)`` — ``weight`` is the
-        number of distinct call sites in the caller targeting the callee.
-        Provenance is always ``["codeql"]``; combine with Jedi-derived
-        edges via ``call_graph.merge_edges``.
-        """
-        edge_counts: Counter = Counter()
-        for source_sig, target_sig, _row in self._iter_resolved_rows(symbol_table):
-            edge_counts[(source_sig, target_sig)] += 1
-
-        return [
-            PyCallEdge(
-                source=src,
-                target=dst,
-                weight=count,
-                provenance=["codeql"],
-            )
-            for (src, dst), count in edge_counts.items()
-        ]
-
-    def augment_call_sites(self, symbol_table: Dict[str, PyModule]) -> int:
-        """Backfill ``PyCallsite.callee_signature`` using CodeQL resolution.
-
-        Walks every CodeQL row, locates the matching ``PyCallsite`` inside
-        the caller's ``PyCallable.call_sites`` by call-expression line range
-        (``start_line``, ``end_line``), and fills in ``callee_signature``
-        **only when Jedi left it empty**. Existing Jedi-resolved signatures
-        are kept (Jedi sees lexical context CodeQL can't, e.g. closures).
-
-        Match is by line range — column matching is brittle across the two
-        tools' 0- vs 1-based conventions. Ambiguity on a single line
-        (e.g. ``a.b().c()``) resolves to the first matching site, which is
-        an acceptable approximation given how rarely Jedi misses callees
-        on chained call lines.
-
-        Returns:
-            Number of ``PyCallsite`` entries augmented.
-        """
-        resolver = self._build_callable_resolver(symbol_table)
-        df = self._query_call_edges()
-        if df.empty:
-            return 0
-
-        augmented = 0
-        for row in df.itertuples(index=False):
-            caller = resolver.resolve(
-                row.caller_file,
-                int(row.caller_start_line),
-                row.caller_name,
-                int(row.caller_arity),
-            )
-            if caller is None:
-                continue
-
-            callee = resolver.resolve(
-                row.callee_file,
-                int(row.callee_start_line),
-                row.callee_name,
-                int(row.callee_arity),
-            )
-            resolved_sig = callee.signature if callee is not None else row.callee_qname
-
-            call_start = int(row.call_start_line)
-            call_end = int(row.call_end_line)
-            for site in caller.call_sites:
-                if site.start_line != call_start or site.end_line != call_end:
-                    continue
-                if not site.callee_signature:
-                    site.callee_signature = resolved_sig
-                    augmented += 1
-                break
-
-        if augmented:
-            logger.debug(
-                f"CodeQL: augmented {augmented} PyCallsite.callee_signature entries."
-            )
-        return augmented

codeanalyzer/semantic_analysis/codeql/codeql_exceptions.py

@@ -1,12 +0,0 @@
-class CodeQLExceptions:
-    class CodeQLDatabaseBuildException(Exception):
-        """Exception raised when there is an error building the CodeQL database."""
-
-        def __init__(self, message: str) -> None:
-            super().__init__(message)
-
-    class CodeQLQueryExecutionException(Exception):
-        """Exception raised when there is an error building the CodeQL database."""
-
-        def __init__(self, message: str) -> None:
-            super().__init__(message)

codeanalyzer/semantic_analysis/codeql/codeql_loader.py

@@ -1,91 +0,0 @@
-import os
-import platform
-import stat
-import zipfile
-from pathlib import Path
-
-import requests
-from codeanalyzer.utils import logger
-
-
-class CodeQLLoader:
-    @classmethod
-    def detect_platform_key(cls) -> str:
-        system = platform.system()
-        arch = platform.machine().lower()
-
-        if system == "Linux" and arch in {"x86_64", "amd64"}:
-            return "codeql-linux64.zip"
-        elif system == "Darwin" and arch in {"x86_64", "arm64"}:
-            return "codeql-osx64.zip"
-        elif system == "Windows" and arch in {"x86_64", "amd64"}:
-            return "codeql-win64.zip"
-        else:
-            return "codeql.zip"  # fallback to generic binary if needed
-
-    @classmethod
-    def get_codeql_download_url(cls, expected_filename: str) -> str:
-        response = requests.get(
-            "https://api.github.com/repos/github/codeql-cli-binaries/releases/latest"
-        )
-        response.raise_for_status()
-        for asset in response.json()["assets"]:
-            if asset["name"] == expected_filename:
-                return asset["browser_download_url"]
-        raise RuntimeError(f"No asset found for filename: {expected_filename}")
-
-    @classmethod
-    def download_and_extract_codeql(cls, temp_dir: Path) -> Path:
-        filename = cls.detect_platform_key()
-        download_url = cls.get_codeql_download_url(filename)
-
-        temp_dir.mkdir(parents=True, exist_ok=True)
-        archive_path = temp_dir / filename
-
-        logger.info(f"Downloading CodeQL CLI from {download_url}")
-        with requests.get(download_url, stream=True) as r:
-            r.raise_for_status()
-            block_size = 8192  # 8KB
-
-            with open(archive_path, "wb") as f:
-                for chunk in r.iter_content(chunk_size=block_size):
-                    f.write(chunk)
-
-        extract_dir = temp_dir / filename.replace(".zip", "")
-        extract_dir.mkdir(exist_ok=True)
-
-        logger.info(f"Extracting CodeQL CLI to {extract_dir}")
-        # zipfile.extractall drops Unix permissions (the executable bit), so
-        # we extract entries manually and copy each one's stored mode onto
-        # the file system. Without this, the CodeQL launcher script can't
-        # be executed and the next subprocess.Popen raises PermissionError.
-        with zipfile.ZipFile(archive_path, "r") as zip_ref:
-            for info in zip_ref.infolist():
-                extracted_path = zip_ref.extract(info, extract_dir)
-                stored_mode = info.external_attr >> 16
-                if stored_mode:
-                    os.chmod(extracted_path, stored_mode)
-
-        # Archive is no longer needed once extracted.
-        try:
-            archive_path.unlink()
-        except OSError as exc:
-            logger.warning(f"Could not remove CodeQL archive {archive_path}: {exc}")
-
-        # rglob("codeql") returns both the launcher file *and* an internal
-        # directory of the same name (CodeQL ships its own runtime under
-        # ``codeql/codeql/``); insist on a regular file so we never bind to
-        # the directory.
-        codeql_bin = next(
-            (p for p in extract_dir.rglob("codeql") if p.is_file()),
-            None,
-        )
-        if not codeql_bin:
-            raise FileNotFoundError("CodeQL binary not found in extracted contents.")
-
-        # Belt-and-suspenders: ensure the binary is executable even if the
-        # archive entry's mode was zero (some older zip producers omit it).
-        st = codeql_bin.stat()
-        codeql_bin.chmod(st.st_mode | stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH)
-
-        return codeql_bin.resolve()

codeanalyzer/semantic_analysis/codeql/codeql_query_runner.py

@@ -1,185 +0,0 @@
-################################################################################
-# Copyright IBM Corporation 2025
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#       http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-################################################################################
-
-"""Backend module for CodeQL query execution.
-
-This module provides functionality to run CodeQL queries against CodeQL databases
-and process the results.
-"""
-
-import shlex
-import subprocess
-import tempfile
-from pathlib import Path
-from typing import List
-
-import pandas as pd
-from pandas import DataFrame
-
-from codeanalyzer.semantic_analysis.codeql.codeql_exceptions import CodeQLExceptions
-
-
-class CodeQLQueryRunner:
-    """A class for executing CodeQL queries against a CodeQL database.
-
-    This class provides a context manager interface for executing CodeQL queries
-    and handling temporary resources needed during query execution.
-
-    Args:
-        database_path (str): The path to the CodeQL database.
-        codeql_bin (str | Path | None): Absolute path to the CodeQL CLI
-            binary. When ``None``, falls back to whatever ``codeql`` is on
-            ``PATH``.
-
-    Attributes:
-        database_path (Path): The path to the CodeQL database.
-        codeql_bin (str): Resolved binary path or the literal ``"codeql"``.
-        temp_file_path (Path): The path to the temporary query file.
-        csv_output_file (Path): The path to the CSV output file.
-        temp_bqrs_file_path (Path): The path to the temporary bqrs file.
-        temp_qlpack_file (Path): The path to the temporary qlpack file.
-
-    Raises:
-        CodeQLQueryExecutionException: If there is an error executing the query.
-    """
-
-    def __init__(self, database_path: str, codeql_bin=None, codeql_packs_dir=None):
-        self.database_path: Path = Path(database_path)
-        self.codeql_bin: str = str(codeql_bin) if codeql_bin else "codeql"
-        self.codeql_packs_dir = (
-            Path(codeql_packs_dir) if codeql_packs_dir is not None else None
-        )
-        self.temp_file_path: Path = None
-
-    def __enter__(self):
-        """Context entry that prepares paths to execute a CodeQL query.
-
-        The ``.ql`` file is written **inside the prepared qlpack
-        directory** (``codeql_packs_dir``) so ``import python`` resolves
-        against that pack's installed dependencies — no
-        ``--additional-packs`` or ``--search-path`` needed. The CSV /
-        BQRS output files live in ``tempfile`` because they're transient
-        per-query artifacts.
-        """
-        # CSV and BQRS files are transient per-query — fine in /tmp.
-        csv_file = tempfile.NamedTemporaryFile("w", delete=False, suffix=".csv")
-        bqrs_file = tempfile.NamedTemporaryFile("w", delete=False, suffix=".bqrs")
-        self.csv_output_file = Path(csv_file.name)
-        self.temp_bqrs_file_path = Path(bqrs_file.name)
-        csv_file.close()
-        bqrs_file.close()
-
-        # The .ql file MUST live inside the prepared qlpack so its
-        # ``import python`` resolves via that pack's lock file. Writing
-        # outside the pack means CodeQL falls back to a default
-        # search-path that doesn't include downloaded library packs.
-        if self.codeql_packs_dir is None:
-            raise RuntimeError(
-                "CodeQLQueryRunner requires codeql_packs_dir — the directory "
-                "of an installed qlpack that depends on codeql/python-all."
-            )
-        ql_file = tempfile.NamedTemporaryFile(
-            "w", delete=False, suffix=".ql", dir=str(self.codeql_packs_dir)
-        )
-        self.temp_file_path = Path(ql_file.name)
-        ql_file.close()
-
-        return self
-
-    def execute(self, query_string: str, column_names: List[str]) -> DataFrame:
-        """Writes the query to the temporary file and executes it against the specified CodeQL database.
-
-        Args:
-            query_string (str): The CodeQL query string to be executed.
-            column_names (List[str]): The list of column names for the CSV the CodeQL produces when we execute the query.
-
-        Returns:
-            dict: A dictionary containing the resulting DataFrame.
-
-        Raises:
-            RuntimeError: If the context manager is not entered using the 'with' statement.
-            CodeQLQueryExecutionException: If there is an error executing the query.
-        """
-        if not self.temp_file_path:
-            raise RuntimeError("CodeQLQueryRunner not entered using 'with' statement.")
-
-        # Write the query to the temp file so we can execute it.
-        self.temp_file_path.write_text(query_string)
-
-        # The .ql file sits inside the qlpack directory whose lock file
-        # already resolves ``codeql/python-all`` and its transitive
-        # dependencies. ``codeql query run`` auto-discovers the enclosing
-        # qlpack — no extra flags required.
-        codeql_query_cmd = shlex.split(
-            f"{shlex.quote(self.codeql_bin)} query run {self.temp_file_path} "
-            f"--database={self.database_path} "
-            f"--output={self.temp_bqrs_file_path}",
-            posix=False,
-        )
-
-        call = subprocess.Popen(
-            codeql_query_cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE
-        )
-        _, err = call.communicate()
-        if call.returncode != 0:
-            raise CodeQLExceptions.CodeQLQueryExecutionException(
-                f"Error executing query: {(err or b'').decode(errors='replace')}"
-            )
-
-        # Convert the bqrs file to a CSV file
-        bqrs2csv_command = shlex.split(
-            f"{shlex.quote(self.codeql_bin)} bqrs decode --format=csv --output={self.csv_output_file} {self.temp_bqrs_file_path}",
-            posix=False,
-        )
-
-        # Read the CSV file content and cast it to a DataFrame
-
-        call = subprocess.Popen(
-            bqrs2csv_command, stdout=subprocess.PIPE, stderr=subprocess.PIPE
-        )
-        _, err = call.communicate()
-        if call.returncode != 0:
-            raise CodeQLExceptions.CodeQLQueryExecutionException(
-                f"Error decoding bqrs: {(err or b'').decode(errors='replace')}"
-            )
-        else:
-            return pd.read_csv(
-                self.csv_output_file,
-                header=None,
-                names=column_names,
-                skiprows=[0],
-            )
-
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        """Clean up resources used by the CodeQL analysis.
-
-        Args:
-            exc_type: The exception type if an exception was raised in the context, otherwise None.
-            exc_val: The exception instance if an exception was raised in the context, otherwise None.
-            exc_tb: The traceback if an exception was raised in the context, otherwise None.
-
-        Note:
-            Deletes the temporary files created during the analysis, including the temporary file path,
-            the CSV output file, and the temporary QL pack file.
-        """
-        if self.temp_file_path and self.temp_file_path.exists():
-            self.temp_file_path.unlink()
-
-        if self.csv_output_file and self.csv_output_file.exists():
-            self.csv_output_file.unlink()
-
-        if self.temp_bqrs_file_path and self.temp_bqrs_file_path.exists():
-            self.temp_bqrs_file_path.unlink()