pheval 0.1.0__py3-none-any.whl → 0.2.0__py3-none-any.whl

pheval/run_metadata.py

@@ -0,0 +1,27 @@
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+from serde import serde
+
+
+@serde
+@dataclass
+class BasicOutputRunMetaData:
+    """Class for defining variables for the run metadata.
+    Args:
+        tool (str): Name of the tool implementation
+        tool_version (str): Version of the tool implementation
+        config (Path): Path to the config file located in the input directory
+        run_timestamp (int): Time taken for run to complete
+        corpus (Path): Path to corpus used in pheval run
+        tool_specific_configuration_options (Any): Special field that can be overwritten by tool implementations to
+                                                   contain any extra tool specific configurations used in the run
+    """
+
+    tool: str
+    tool_version: str
+    config: Path
+    run_timestamp: int
+    corpus: Path
+    tool_specific_configuration_options: Any = None

pheval/runners/runner.py

@@ -1,19 +1,95 @@
 """Runners Module"""
 from abc import ABC, abstractmethod
 from dataclasses import dataclass
+from datetime import datetime
+from pathlib import Path
 
-import click
+from pheval.config_parser import parse_input_dir_config
+from pheval.run_metadata import BasicOutputRunMetaData
 
 
 @dataclass
 class PhEvalRunner(ABC):
     """PhEvalRunner Class"""
 
-    inputdir: click.Path
-    testdatadir: click.Path
-    tmpdir: click.Path
-    outputdir: click.Path
-    config: click.Path
+    input_dir: Path
+    testdata_dir: Path
+    tmp_dir: Path
+    output_dir: Path
+    config_file: Path
+    version: str
+    directory_path = None
+    input_dir_config = None
+    _meta_data = None
+    __raw_results_dir = "raw_results/"
+    __pheval_gene_results_dir = "pheval_gene_results/"
+    __pheval_variant_results_dir = "pheval_variant_results/"
+    __tool_input_commands_dir = "tool_input_commands/"
+    __run_meta_data_file = "results.yml"
+
+    def __post_init__(self):
+        self.input_dir_config = parse_input_dir_config(self.input_dir)
+
+    def _get_tool(self):
+        return self.input_dir_config.tool
+
+    def _get_phenotype_only(self):
+        return self.input_dir_config.phenotype_only
+
+    @property
+    def tool_input_commands_dir(self):
+        return Path(self.output_dir).joinpath(self.__tool_input_commands_dir)
+
+    @tool_input_commands_dir.setter
+    def tool_input_commands_dir(self, directory_path):
+        self.directory_path = Path(directory_path)
+
+    @property
+    def raw_results_dir(self):
+        return Path(self.output_dir).joinpath(self.__raw_results_dir)
+
+    @raw_results_dir.setter
+    def raw_results_dir(self, directory_path):
+        self.directory_path = Path(directory_path)
+
+    @property
+    def pheval_gene_results_dir(self):
+        return Path(self.output_dir).joinpath(self.__pheval_gene_results_dir)
+
+    @pheval_gene_results_dir.setter
+    def pheval_gene_results_dir(self, directory_path):
+        self.directory_path = Path(directory_path)
+
+    @property
+    def pheval_variant_results_dir(self):
+        return Path(self.output_dir).joinpath(self.__pheval_variant_results_dir)
+
+    @pheval_variant_results_dir.setter
+    def pheval_variant_results_dir(self, directory_path):
+        self.directory_path = Path(directory_path)
+
+    def build_output_directory_structure(self):
+        """build output directory structure"""
+        self.tool_input_commands_dir.mkdir(exist_ok=True)
+        self.raw_results_dir.mkdir(exist_ok=True)
+        self.pheval_gene_results_dir.mkdir(exist_ok=True)
+        if not self._get_phenotype_only():
+            self.pheval_variant_results_dir.mkdir(exist_ok=True)
+
+    @property
+    def meta_data(self):
+        self._meta_data = BasicOutputRunMetaData(
+            tool=self.input_dir_config.tool,
+            tool_version=self.version,
+            config=f"{Path(self.input_dir).parent.name}/{Path(self.input_dir).name}",
+            run_timestamp=datetime.now().timestamp(),
+            corpus=f"{Path(self.testdata_dir).parent.name}/{Path(self.testdata_dir).name}",
+        )
+        return self._meta_data
+
+    @meta_data.setter
+    def meta_data(self, meta_data):
+        self._meta_data = meta_data
 
     @abstractmethod
     def prepare(self) -> str:
@@ -27,6 +103,10 @@ class PhEvalRunner(ABC):
     def post_process(self):
         """post_process"""
 
+    def construct_meta_data(self):
+        """Construct run output meta data"""
+        return self.meta_data
+
 
 class DefaultPhEvalRunner(PhEvalRunner):
     """DefaultPhEvalRunner
@@ -35,11 +115,12 @@ class DefaultPhEvalRunner(PhEvalRunner):
         PhEvalRunner (PhEvalRunner): Abstract PhEvalRunnerClass
     """
 
-    inputdir: click.Path
-    testdatadir: click.Path
-    tmpdir: click.Path
-    outputdir: click.Path
-    config: click.Path
+    input_dir: Path
+    testdata_dir: Path
+    tmp_dir: Path
+    output_dir: Path
+    config_file: Path
+    version: str
 
     def prepare(self):
         print("preparing")

pheval/utils/docs_gen.py

@@ -0,0 +1,105 @@
+"""docs generate utils"""
+import ast
+import os
+import shutil
+from pathlib import Path
+
+
+def find_methods_in_python_file(file_path):
+    """Return method names from a python file
+
+    Args:
+        file_path ([type]): [description]
+    """
+    methods = []
+    with open(file_path, "r", encoding="utf-8") as file:
+        text = file.read()
+        parsed = ast.parse(text)
+        for node in ast.walk(parsed):
+            if isinstance(node, ast.FunctionDef):
+                methods.append(node.name)
+
+    return methods
+
+
+def list_valid_files():
+    """This method lists the files whose documentation will be generated, excluding folders and empty files"""
+    ignored_files = ["docs_gen", "__init__"]
+    source_folder = "./src"
+    files = Path(source_folder).rglob("*.py")
+    filtered_files = []
+    for file in files:
+        if os.stat(file).st_size == 0 or not os.path.isfile(file):
+            continue
+
+        folder_parts = Path(file).parts
+        folder = "/".join(folder_parts[:-1])
+        basename = os.path.basename(file).split(".")[0]
+
+        docs_path = f"./docs/api/{folder.replace('src/', '')}/{basename}.md"
+        if basename in ignored_files:
+            continue
+
+        filtered_files.append(
+            {
+                "path": file,
+                "docs_path": docs_path,
+                "basename": basename,
+                "folder": folder,
+            }
+        )
+
+    return filtered_files
+
+
+def print_api_doc(file_item):
+    "Writes the file path using the mkdocs pattern"
+    clean_path = str(file_item["folder"]).replace("./", "").replace("/", ".")
+    write_doc(file_item, f"::: {clean_path}.{file_item['basename']}")
+
+
+def write_doc(file_item, content):
+    """Creates folder structures and writes file content"""
+    os.makedirs(os.path.dirname(file_item["docs_path"]), exist_ok=True)
+    with open(file_item["docs_path"], "a", encoding="utf-8") as file:
+        file.write(content)
+
+
+def print_cli_doc(file_item):
+    """Documentation specific to the CLI is generated by this method.
+    When it comes to a CLI, mkdocs click must be used."""
+    methods = find_methods_in_python_file(file_item["path"])
+    for method in methods:
+        content = f"""
+::: mkdocs-click
+    :package: {file_item['folder'].replace("./", '').replace('/', '.')}.{file_item['basename']}
+    :module: {file_item['folder'].replace("./", '').replace('/', '.').replace('src.', '')}.{file_item['basename']}
+    :command: {method}
+    :depth: 4
+    :style: table
+    :list_subcommands: true
+        """
+        write_doc(file_item, content)
+
+
+def gen_docs():
+    """The main method for generating documentation"""
+    api_folder = f"{os.path.abspath(os.curdir)}/docs/api"
+    print(api_folder)
+    shutil.rmtree(api_folder, ignore_errors=True)
+    valid_files = list_valid_files()
+    print(valid_files)
+    for file_item in valid_files:
+        bname = file_item["basename"]
+        if bname == "cli":  # or bname.startswith("cli_"):
+            print(bname)
+            print_cli_doc(file_item)
+        elif bname.startswith("cli_"):
+            continue
+        else:
+            print_api_doc(file_item)
+    print("done")
+
+
+if __name__ == "__main__":
+    gen_docs()

pheval/utils/docs_gen.sh

@@ -0,0 +1,18 @@
+#!/bin/bash
+
+# set -e
+cd ../../../
+SOURCE_FOLDER='./src'
+FILES=$(find $SOURCE_FOLDER -type f -iname '*.py' -not -iname '__init__.py' -not -empty)
+rm -rf ./docs/api
+
+for f in $FILES
+do
+    clean_dir=${f#./src/}
+    last_folder=`dirname $clean_dir`
+    full_fname="${f##*/}"
+    fname="${full_fname%%.*}"
+    mkdir -p ./docs/api/$last_folder
+    ref=$(echo $f | sed 's#/#.#g' | sed 's/..src/src/g' | sed 's/\.[^.]*$//')
+    echo ::: $ref >> ./docs/api/$last_folder/$fname.md
+done

pheval/utils/file_utils.py

@@ -0,0 +1,88 @@
+import difflib
+import itertools
+import re
+import unicodedata
+from os import path
+from pathlib import Path
+from typing import List
+
+import pandas as pd
+import yaml
+from serde import to_dict
+
+from pheval.run_metadata import BasicOutputRunMetaData
+
+
+def files_with_suffix(directory: Path, suffix: str):
+    """Obtains all files ending in a specified suffix from a given directory."""
+    files = [path for path in directory.iterdir() if path.suffix == suffix]
+    files.sort()
+    return files
+
+
+def all_files(directory: Path) -> list[Path]:
+    """Obtains all files from a given directory."""
+    files = [path for path in directory.iterdir()]
+    files.sort()
+    return files
+
+
+def is_gzipped(path: Path) -> bool:
+    """Confirms whether a file is gzipped."""
+    return path.name.endswith(".gz")
+
+
+def normalise_file_name(file_path: Path) -> str:
+    normalised_file_name = unicodedata.normalize("NFD", str(file_path))
+    return re.sub("[\u0300-\u036f]", "", normalised_file_name)
+
+
+def obtain_closest_file_name(file_to_be_queried: Path, file_paths: list[Path]) -> Path:
+    """Obtains the closest file name when given a template file name and a list of full path of files to be queried."""
+    stems = [Path(file_path).stem for file_path in file_paths]
+    closest_file_match = difflib.get_close_matches(
+        str(Path(file_to_be_queried).stem), stems, cutoff=0.1, n=1
+    )[0]
+    return [file_path for file_path in file_paths if closest_file_match == str(file_path.stem)][0]
+
+
+def ensure_file_exists(*files: str):
+    """Ensures the existence of files passed as parameter
+    Raises:
+        FileNotFoundError: If any file passed as a parameter doesn't exist a FileNotFound Exception will be raised
+    """
+    for file in files:
+        if not path.isfile(file):
+            raise FileNotFoundError(f"File {file} not found")
+
+
+def ensure_columns_exists(cols: list, dataframes: List[pd.DataFrame], err_message: str = ""):
+    """Ensures the columns exist in dataframes passed as argument (e.g)
+
+    "
+    ensure_columns_exists(
+        cols=['column_a', 'column_b, 'column_c'],
+        err_message="Custom error message if any column doesn't exist in any dataframe passed as argument",
+        dataframes=[data_frame1, data_frame2],
+    )
+    "
+
+    """
+    flat_cols = list(itertools.chain(cols))
+    if not dataframes or not flat_cols:
+        return
+    if err_message:
+        err_msg = f"""columns: {", ".join(flat_cols[:-1])} and {flat_cols[-1]} {err_message}"""
+    else:
+        err_msg = f"""columns: {", ".join(flat_cols[:-1])} and {flat_cols[-1]} \
+- must be present in both left and right files"""
+    for dataframe in dataframes:
+        if not all(x in dataframe.columns for x in flat_cols):
+            raise ValueError(err_msg)
+
+
+def write_metadata(output_dir: Path, meta_data: BasicOutputRunMetaData) -> None:
+    """Write the metadata for a run."""
+    with open(Path(output_dir).joinpath("results.yml"), "w") as metadata_file:
+        yaml.dump(to_dict(meta_data), metadata_file, sort_keys=False, default_style="")
+    metadata_file.close()