pheval 0.3.9__tar.gz → 0.4.0__tar.gz

pheval-0.4.0/PKG-INFO

@@ -0,0 +1,112 @@
+Metadata-Version: 2.1
+Name: pheval
+Version: 0.4.0
+Summary: 
+Author: Yasemin Bridges
+Author-email: y.bridges@qmul.ac.uk
+Requires-Python: >=3.9,<4.0.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: class-resolver (>=0.4.2)
+Requires-Dist: click (>=8.1.3)
+Requires-Dist: deprecation (>=2.1.0)
+Requires-Dist: duckdb (>=1.0.0,<2.0.0)
+Requires-Dist: google (>=3.0.0,<4.0.0)
+Requires-Dist: jaydebeapi (>=1.2.3)
+Requires-Dist: matplotlib (>=3.7.0,<4.0.0)
+Requires-Dist: oaklib (>=0.5.6)
+Requires-Dist: pandas (>=1.5.1)
+Requires-Dist: phenopackets (>=2.0.2,<3.0.0)
+Requires-Dist: plotly (>=5.13.0,<6.0.0)
+Requires-Dist: polars (>=0.19.15,<0.20.0)
+Requires-Dist: pyaml (>=21.10.1,<22.0.0)
+Requires-Dist: pyserde (>=0.9.8,<0.10.0)
+Requires-Dist: scikit-learn (>=1.4.0,<2.0.0)
+Requires-Dist: seaborn (>=0.12.2,<0.13.0)
+Requires-Dist: tqdm (>=4.64.1)
+Description-Content-Type: text/markdown
+
+# PhEval - Phenotypic Inference Evaluation Framework
+
+![PyPI](https://img.shields.io/pypi/v/pheval)
+![Build Status](https://img.shields.io/github/actions/workflow/status/monarch-initiative/pheval/pypi-publish.yml?branch=main)
+![License](https://img.shields.io/github/license/monarch-initiative/pheval)
+![Python Version](https://img.shields.io/badge/python-3.8%2B-blue)
+![Issues](https://img.shields.io/github/issues/monarch-initiative/pheval)
+
+## Overview
+
+The absence of standardised benchmarks and data standardisation for Variant and Gene Prioritisation Algorithms (VGPAs) presents a significant challenge in the field of genomic research. To address this, we developed PhEval, a novel framework designed to streamline the evaluation of VGPAs that incorporate phenotypic data. PhEval offers several key benefits:
+
+- Automated Processes: Reduces manual effort by automating various evaluation tasks, thus enhancing efficiency.
+- Standardisation: Ensures consistency and comparability in evaluation methodologies, leading to more reliable and standardised assessments.
+- Reproducibility: Facilitates reproducibility in research by providing a standardised platform, allowing for consistent validation of algorithms.
+- Comprehensive Benchmarking: Enables thorough benchmarking of algorithms, providing well-founded comparisons and deeper insights into their performance. 
+
+PhEval is a valuable tool for researchers looking to improve the accuracy and reliability of VGPA evaluations through a structured and standardised approach.
+
+For more information please see the full [documentation](https://monarch-initiative.github.io/pheval/).
+
+## Download and Installation
+
+1. Ensure you have Python 3.8 or greater installed.
+2. Install with `pip`:
+```bash
+pip install pheval
+```
+3. See list of all PhEval utility commands:
+```bash
+pheval-utils --help
+```
+
+## Usage
+
+The PhEval CLI offers a variety of commands categorised into two main types: **Runner Implementations** and **Utility Commands**. Below is an overview of each category, detailing how they can be utilised to perform various tasks within PhEval.
+
+### Runner Implementations
+
+The primary command used within PhEval is `pheval run`. This command is responsible for executing concrete VGPA runner implementations, that we sometimes term as plugins. By using pheval run, users can leverage these runner implementations to: execute the VGPA on a set of test corpora, produce tool-specific result outputs, and post-process tool-specific outputs to PhEval standardised TSV outputs.
+
+Some concrete PhEval runner implementations include the [Exomiser runner](https://github.com/monarch-initiative/pheval.exomiser) and the [Phen2Gene runner](https://github.com/monarch-initiative/pheval.phen2gene). The full list of currently implemented runners can be found [here](https://monarch-initiative.github.io/pheval/plugins/)
+
+Please read the [documentation](https://monarch-initiative.github.io/pheval/developing_a_pheval_plugin/) for a step-by-step for creating your own PhEval plugin. 
+
+### Utility Commands
+
+In addition to the main `run` command, PhEval provides a set of utility commands designed to enhance the overall functionality of the CLI. These commands can be used to set up and configure experiments, streamline data preparation, and benchmark the performance of various VGPA runner implementations. By utilising these utilities, users can optimise their experimental workflows, ensure reproducibility, and compare the efficiency and accuracy of different approaches. The utility commands offer a range of options that facilitate the customisation and fine-tuning to suit diverse research objectives.
+
+#### Example Usage
+
+To add noise to an existing corpus of phenopackets, this could be used to assess the robustness of VGPAs when less relevant or unreliable phenotype data is introduced:
+```bash
+pheval-utils scramble-phenopackets --phenopacket-dir /phenopackets --scramble-factor 0.5 --output-dir /scrambled_phenopackets_0.5
+```
+
+To update the gene symbols and identifiers to a specific namespace:
+```bash
+pheval-utils update-phenopackets --phenopacket-dir /phenopackets --output-dir /updated_phenopackets --gene-identifier ensembl_id
+```
+
+To prepare VCF files for a corpus of phenopackets, spiking in the known causative variants:
+```bash
+pheval-utils create-spiked-vcfs --phenopacket-dir /phenopackets --hg19-template-vcf /template_hg19.vcf --hg38-template-vcf /template_hg38.vcf --output-dir /vcf
+```
+
+Alternatively, you can wrap all corpus preparatory commands into a single step. Specifying `--variant-analysis`/`--gene-analysis`/`--disease-analysis` will check the phenopackets for complete records documenting the known entities. If template vcf(s) are provided this will spike VCFs with the known variant for the corpus. If a `--gene-identifier` is specified then the corpus of phenopackets is updated.
+```bash
+pheval-utils prepare-corpus \
+    --phenopacket-dir /phenopackets \
+    --variant-analysis \
+    --gene-analysis \
+    --gene-identifier ensembl_id \
+    --hg19-template-vcf /template_hg19.vcf \
+    --hg38-template-vcf /template_hg38.vcf \
+    --output-dir /vcf
+```
+
+See the [documentation](https://monarch-initiative.github.io/pheval/executing_a_benchmark/) for instructions on benchmarking and evaluating the performance of various VGPAs.
+
+

pheval-0.4.0/README.md

@@ -0,0 +1,80 @@
+# PhEval - Phenotypic Inference Evaluation Framework
+
+![PyPI](https://img.shields.io/pypi/v/pheval)
+![Build Status](https://img.shields.io/github/actions/workflow/status/monarch-initiative/pheval/pypi-publish.yml?branch=main)
+![License](https://img.shields.io/github/license/monarch-initiative/pheval)
+![Python Version](https://img.shields.io/badge/python-3.8%2B-blue)
+![Issues](https://img.shields.io/github/issues/monarch-initiative/pheval)
+
+## Overview
+
+The absence of standardised benchmarks and data standardisation for Variant and Gene Prioritisation Algorithms (VGPAs) presents a significant challenge in the field of genomic research. To address this, we developed PhEval, a novel framework designed to streamline the evaluation of VGPAs that incorporate phenotypic data. PhEval offers several key benefits:
+
+- Automated Processes: Reduces manual effort by automating various evaluation tasks, thus enhancing efficiency.
+- Standardisation: Ensures consistency and comparability in evaluation methodologies, leading to more reliable and standardised assessments.
+- Reproducibility: Facilitates reproducibility in research by providing a standardised platform, allowing for consistent validation of algorithms.
+- Comprehensive Benchmarking: Enables thorough benchmarking of algorithms, providing well-founded comparisons and deeper insights into their performance. 
+
+PhEval is a valuable tool for researchers looking to improve the accuracy and reliability of VGPA evaluations through a structured and standardised approach.
+
+For more information please see the full [documentation](https://monarch-initiative.github.io/pheval/).
+
+## Download and Installation
+
+1. Ensure you have Python 3.8 or greater installed.
+2. Install with `pip`:
+```bash
+pip install pheval
+```
+3. See list of all PhEval utility commands:
+```bash
+pheval-utils --help
+```
+
+## Usage
+
+The PhEval CLI offers a variety of commands categorised into two main types: **Runner Implementations** and **Utility Commands**. Below is an overview of each category, detailing how they can be utilised to perform various tasks within PhEval.
+
+### Runner Implementations
+
+The primary command used within PhEval is `pheval run`. This command is responsible for executing concrete VGPA runner implementations, that we sometimes term as plugins. By using pheval run, users can leverage these runner implementations to: execute the VGPA on a set of test corpora, produce tool-specific result outputs, and post-process tool-specific outputs to PhEval standardised TSV outputs.
+
+Some concrete PhEval runner implementations include the [Exomiser runner](https://github.com/monarch-initiative/pheval.exomiser) and the [Phen2Gene runner](https://github.com/monarch-initiative/pheval.phen2gene). The full list of currently implemented runners can be found [here](https://monarch-initiative.github.io/pheval/plugins/)
+
+Please read the [documentation](https://monarch-initiative.github.io/pheval/developing_a_pheval_plugin/) for a step-by-step for creating your own PhEval plugin. 
+
+### Utility Commands
+
+In addition to the main `run` command, PhEval provides a set of utility commands designed to enhance the overall functionality of the CLI. These commands can be used to set up and configure experiments, streamline data preparation, and benchmark the performance of various VGPA runner implementations. By utilising these utilities, users can optimise their experimental workflows, ensure reproducibility, and compare the efficiency and accuracy of different approaches. The utility commands offer a range of options that facilitate the customisation and fine-tuning to suit diverse research objectives.
+
+#### Example Usage
+
+To add noise to an existing corpus of phenopackets, this could be used to assess the robustness of VGPAs when less relevant or unreliable phenotype data is introduced:
+```bash
+pheval-utils scramble-phenopackets --phenopacket-dir /phenopackets --scramble-factor 0.5 --output-dir /scrambled_phenopackets_0.5
+```
+
+To update the gene symbols and identifiers to a specific namespace:
+```bash
+pheval-utils update-phenopackets --phenopacket-dir /phenopackets --output-dir /updated_phenopackets --gene-identifier ensembl_id
+```
+
+To prepare VCF files for a corpus of phenopackets, spiking in the known causative variants:
+```bash
+pheval-utils create-spiked-vcfs --phenopacket-dir /phenopackets --hg19-template-vcf /template_hg19.vcf --hg38-template-vcf /template_hg38.vcf --output-dir /vcf
+```
+
+Alternatively, you can wrap all corpus preparatory commands into a single step. Specifying `--variant-analysis`/`--gene-analysis`/`--disease-analysis` will check the phenopackets for complete records documenting the known entities. If template vcf(s) are provided this will spike VCFs with the known variant for the corpus. If a `--gene-identifier` is specified then the corpus of phenopackets is updated.
+```bash
+pheval-utils prepare-corpus \
+    --phenopacket-dir /phenopackets \
+    --variant-analysis \
+    --gene-analysis \
+    --gene-identifier ensembl_id \
+    --hg19-template-vcf /template_hg19.vcf \
+    --hg38-template-vcf /template_hg38.vcf \
+    --output-dir /vcf
+```
+
+See the [documentation](https://monarch-initiative.github.io/pheval/executing_a_benchmark/) for instructions on benchmarking and evaluating the performance of various VGPAs.
+

{pheval-0.3.9 → pheval-0.4.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "pheval"
-version = "0.3.9"
+version = "0.4.0"
 description = ""
 authors = ["Yasemin Bridges <y.bridges@qmul.ac.uk>",
   "Julius Jacobsen <j.jacobsen@qmul.ac.uk>",
@@ -27,10 +27,13 @@ matplotlib = "^3.7.0"
 pyserde = "^0.9.8"
 polars = "^0.19.15"
 scikit-learn = "^1.4.0"
+duckdb = "^1.0.0"
 
 [tool.poetry.dev-dependencies]
 pytest = "^7.2.0"
 coverage = "^6.5.0"
+pheval-template = "^0.1.2"
+pytest-workflow = "^2.0.1"
 
 [tool.poetry.scripts]
 pheval = "pheval.cli:pheval"
@@ -38,15 +41,15 @@ pheval-utils = "pheval.cli:pheval_utils"
 
 [tool.poetry.group.docs.dependencies]
 mkdocs = "^1.4.2"
-pymdown-extensions = "^9.9"
 mkdocs-material = "^8.5.11"
-mkdocstrings = "^0.19.1"
-mkdocstrings-python = "^0.8.2"
+mkdocstrings = "^0.24.0"
+mkdocstrings-python = "^1.8.0"
+pymdown-extensions = "^9.9"
 mkdocs-include-dir-to-nav = "^1.2.0"
 mkdocs-click = "^0.8.0"
+griffe = "0.38.1"
 [tool.poetry.group.dev.dependencies]
 black = "^22.12.0"
-pytest-workflow = "^2.0.1"
 
 [tool.pytest.ini_options]
 pythonpath = [

pheval-0.4.0/src/pheval/analyse/analysis.py

@@ -0,0 +1,104 @@
+from pheval.analyse.benchmark_generator import (
+    BenchmarkRunOutputGenerator,
+    DiseaseBenchmarkRunOutputGenerator,
+    GeneBenchmarkRunOutputGenerator,
+    VariantBenchmarkRunOutputGenerator,
+)
+from pheval.analyse.generate_summary_outputs import generate_benchmark_comparison_output
+from pheval.analyse.parse_corpus import CorpusParser
+from pheval.analyse.rank_stats import RankStatsWriter
+from pheval.analyse.run_data_parser import Config
+
+
+def _run_benchmark_comparison(
+    run_config: Config,
+    benchmark_generator: BenchmarkRunOutputGenerator,
+) -> None:
+    """
+    Run a benchmark on several result directories.
+
+    Args:
+        run_config (List[TrackInputOutputDirectories]): List of input and output directories
+            for tracking results across multiple directories.
+        benchmark_generator (BenchmarkRunOutputGenerator): Generator for benchmark run output.
+    """
+    stats_writer = RankStatsWriter(
+        run_config.benchmark_name, benchmark_generator.stats_comparison_file
+    )
+    unique_test_corpora_directories = set([result.phenopacket_dir for result in run_config.runs])
+    [
+        CorpusParser(run_config.benchmark_name, test_corpora_directory).parse_corpus(
+            benchmark_generator
+        )
+        for test_corpora_directory in unique_test_corpora_directories
+    ]
+    benchmarking_results = []
+    for run in run_config.runs:
+        benchmark_result = benchmark_generator.generate_benchmark_run_results(
+            run_config.benchmark_name, run, run.score_order, run.threshold
+        )
+        stats_writer.add_statistics_entry(
+            run.run_identifier,
+            benchmark_result.rank_stats,
+            benchmark_result.binary_classification_stats,
+        )
+        benchmarking_results.append(benchmark_result)
+    run_identifiers = [run.run_identifier for run in run_config.runs]
+    [
+        generate_benchmark_comparison_output(
+            run_config.benchmark_name,
+            benchmarking_results,
+            run_identifiers,
+            benchmark_generator,
+            f"{unique_test_corpora_directory.parents[0].name}_"
+            f"{benchmark_generator.prioritisation_type_string}",
+        )
+        for unique_test_corpora_directory in unique_test_corpora_directories
+    ]
+
+
+def benchmark_run_comparisons(
+    run_config: Config,
+) -> None:
+    """
+    Benchmark prioritisation performance for several runs.
+
+    Args:
+        run_config (Config): Run configurations.
+    """
+    gene_analysis_runs = Config(
+        benchmark_name=run_config.benchmark_name,
+        runs=[run for run in run_config.runs if run.gene_analysis],
+        plot_customisation=run_config.plot_customisation,
+    )
+    variant_analysis_runs = Config(
+        benchmark_name=run_config.benchmark_name,
+        runs=[run for run in run_config.runs if run.variant_analysis],
+        plot_customisation=run_config.plot_customisation,
+    )
+    disease_analysis_runs = Config(
+        benchmark_name=run_config.benchmark_name,
+        runs=[run for run in run_config.runs if run.disease_analysis],
+        plot_customisation=run_config.plot_customisation,
+    )
+    if gene_analysis_runs.runs:
+        _run_benchmark_comparison(
+            run_config=gene_analysis_runs,
+            benchmark_generator=GeneBenchmarkRunOutputGenerator(
+                plot_customisation=gene_analysis_runs.plot_customisation.gene_plots
+            ),
+        )
+    if variant_analysis_runs.runs:
+        _run_benchmark_comparison(
+            run_config=variant_analysis_runs,
+            benchmark_generator=VariantBenchmarkRunOutputGenerator(
+                plot_customisation=variant_analysis_runs.plot_customisation.variant_plots
+            ),
+        )
+    if disease_analysis_runs.runs:
+        _run_benchmark_comparison(
+            run_config=disease_analysis_runs,
+            benchmark_generator=DiseaseBenchmarkRunOutputGenerator(
+                plot_customisation=disease_analysis_runs.plot_customisation.disease_plots
+            ),
+        )

pheval-0.4.0/src/pheval/analyse/assess_prioritisation_base.py

@@ -0,0 +1,108 @@
+from typing import Union
+
+from pheval.analyse.benchmark_db_manager import BenchmarkDBManager
+from pheval.post_processing.post_processing import (
+    RankedPhEvalDiseaseResult,
+    RankedPhEvalGeneResult,
+    RankedPhEvalVariantResult,
+)
+
+
+class AssessPrioritisationBase:
+    def __init__(
+        self,
+        db_connection: BenchmarkDBManager,
+        table_name: str,
+        column: str,
+        threshold: float,
+        score_order: str,
+    ):
+        """
+        Initialise AssessPrioritisationBase class
+
+        Args:
+            db_connection (BenchmarkDBManager): DB connection.
+            table_name (str): Table name.
+            column (str): Column name.
+            threshold (float): Threshold for scores
+            score_order (str): Score order for results, either ascending or descending
+
+        """
+        self.threshold = threshold
+        self.score_order = score_order
+        self.db_connection = db_connection
+        self.conn = db_connection.conn
+        self.column = column
+        self.table_name = table_name
+        db_connection.add_column_integer_default(
+            table_name=table_name, column=self.column, default=0
+        )
+
+    def _assess_with_threshold_ascending_order(
+        self,
+        result_entry: Union[
+            RankedPhEvalGeneResult, RankedPhEvalDiseaseResult, RankedPhEvalVariantResult
+        ],
+    ) -> int:
+        """
+        Record the prioritisation rank if it meets the ascending order threshold.
+
+
+        Args:
+            result_entry (Union[RankedPhEvalGeneResult, RankedPhEvalDiseaseResult, RankedPhEvalVariantResult]):
+                Ranked PhEval result entry
+
+        Returns:
+            int: Recorded prioritisation rank
+        """
+        if float(self.threshold) > float(result_entry.score):
+            return result_entry.rank
+        else:
+            return 0
+
+    def _assess_with_threshold(
+        self,
+        result_entry: Union[
+            RankedPhEvalGeneResult, RankedPhEvalDiseaseResult, RankedPhEvalVariantResult
+        ],
+    ) -> int:
+        """
+        Record the prioritisation rank if it meets the score threshold.
+
+        Args:
+            result_entry (Union[RankedPhEvalGeneResult, RankedPhEvalDiseaseResult, RankedPhEvalVariantResult]):
+                Ranked PhEval result entry
+
+        Returns:
+            int: Recorded prioritisation rank
+        """
+        if float(self.threshold) < float(result_entry.score):
+            return result_entry.rank
+        else:
+            return 0
+
+    def _record_matched_entity(
+        self,
+        standardised_result: Union[
+            RankedPhEvalGeneResult, RankedPhEvalDiseaseResult, RankedPhEvalVariantResult
+        ],
+    ) -> int:
+        """
+        Return the rank result - handling the specification of a threshold.
+        Args:
+            standardised_result (Union[RankedPhEvalGeneResult, RankedPhEvalDiseaseResult, RankedPhEvalVariantResult]):
+                Ranked PhEval disease result entry
+
+        Returns:
+            int: Recorded entity prioritisation rank
+        """
+        if float(self.threshold) == 0.0:
+            return standardised_result.rank
+        else:
+            return (
+                self._assess_with_threshold(standardised_result)
+                if self.score_order != "ascending"
+                else self._assess_with_threshold_ascending_order(
+                    standardised_result,
+                )
+            )

pheval-0.4.0/src/pheval/analyse/benchmark_db_manager.py

@@ -0,0 +1,140 @@
+import ast
+import re
+from typing import List, Type, Union
+
+import duckdb
+from duckdb import DuckDBPyConnection
+
+from pheval.post_processing.post_processing import (
+    RankedPhEvalDiseaseResult,
+    RankedPhEvalGeneResult,
+    RankedPhEvalVariantResult,
+)
+
+
+class BenchmarkDBManager:
+    """
+    Class to connect to database.
+    """
+
+    def __init__(self, benchmark_name: str):
+        """Initialise the BenchmarkDBManager class."""
+        self.conn = self.get_connection(
+            f"{benchmark_name}" if str(benchmark_name).endswith(".db") else f"{benchmark_name}.db"
+        )
+
+    def initialise(self):
+        """Initialise the duckdb connection."""
+        self.add_contains_function()
+
+    @staticmethod
+    def get_connection(db_name: str) -> DuckDBPyConnection:
+        """
+        Get a connection to the database.
+        Returns:
+            DuckDBPyConnection: Connection to the database.
+        """
+        conn = duckdb.connect(db_name)
+        return conn
+
+    def add_column_integer_default(self, table_name: str, column: str, default: int = 0) -> None:
+        """
+        Add a column to an existing table with an integer default value.
+        Args:
+            table_name (str): Name of the table.
+            column (str): Name of the column to add.
+            default (int): Default integer value to add.
+        """
+        try:
+            self.conn.execute(
+                f'ALTER TABLE {table_name} ADD COLUMN "{column}" INTEGER DEFAULT {default}'
+            )
+            self.conn.execute(f'UPDATE {table_name} SET "{column}" = ?', (default,))
+            self.conn.commit()
+        except duckdb.CatalogException:
+            pass
+
+    def drop_table(self, table_name: str) -> None:
+        """
+        Drop a table from the database.
+        Args:
+            table_name: Name of the table to drop from the database
+        """
+        self.conn.execute(f"""DROP TABLE IF EXISTS "{table_name}";""")
+
+    @staticmethod
+    def contains_entity_function(entity: str, known_causative_entity: str) -> bool:
+        """
+        Determines if a known causative entity is present within an entity or list of entities.
+        Args:
+            entity (str): The entity to be checked. It can be a single entity or a string representation of a list.
+            known_causative_entity (str): The entity to search for within the `entity`.
+
+        Returns:
+            bool: `True` if `known_causative_entity` is found in `entity` (or its list representation),
+                `False` otherwise.
+        """
+        list_pattern = re.compile(r"^\[\s*(?:[^\[\],\s]+(?:\s*,\s*[^\[\],\s]+)*)?\s*]$")
+        if list_pattern.match(str(entity)):
+            list_representation = ast.literal_eval(entity)
+            if isinstance(list_representation, list):
+                return known_causative_entity in list_representation
+        return known_causative_entity == entity
+
+    def add_contains_function(self) -> None:
+        """
+        Adds a custom `contains_entity_function` to the DuckDB connection if it does not already exist.
+        """
+        result = self.conn.execute(
+            "SELECT * FROM duckdb_functions() WHERE function_name = ?", ["contains_entity_function"]
+        ).fetchall()
+        if not result:
+            self.conn.create_function("contains_entity_function", self.contains_entity_function)
+
+    def parse_table_into_dataclass(
+        self,
+        table_name: str,
+        dataclass: Union[
+            Type[RankedPhEvalGeneResult],
+            Type[RankedPhEvalVariantResult],
+            Type[RankedPhEvalDiseaseResult],
+        ],
+    ) -> Union[
+        List[RankedPhEvalGeneResult],
+        List[RankedPhEvalVariantResult],
+        List[RankedPhEvalDiseaseResult],
+    ]:
+        """
+        Parses a DuckDB table into a list of dataclass instances.
+        Args:
+            table_name (str): The name of the DuckDB table to be parsed.
+            dataclass (Union[Type[RankedPhEvalGeneResult], Type[RankedPhEvalVariantResult],
+            Type[RankedPhEvalDiseaseResult]]):
+                The dataclass type to which each row in the table should be mapped.
+
+        Returns:
+            List[dataclass]: A list of instances of the provided dataclass, each representing a row from the table.
+        """
+        result = (
+            self.conn.execute(f"SELECT * FROM '{table_name}'").fetchdf().to_dict(orient="records")
+        )
+        return [dataclass(**row) for row in result]
+
+    def check_table_exists(self, table_name: str) -> bool:
+        """
+        Check if a table exists in the connected DuckDB database.
+        Args:
+            table_name (str): The name of the table to check for existence.
+        Returns:
+            bool: Returns `True` if the table exists in the database, `False` otherwise.
+        """
+        result = self.conn.execute(
+            f"SELECT * FROM information_schema.tables WHERE table_name = '{table_name}'"
+        ).fetchall()
+        if result:
+            return True
+        return False
+
+    def close(self):
+        """Close the connection to the database."""
+        self.conn.close()