pythonQEPest 2.0.0a2__py3-none-any.whl

pythonQEPest/.env.example

@@ -0,0 +1,4 @@
+LOG_LEVEL="INFO"
+LOG_FILE_LOCATION="logs/app.log"
+
+APP_DEBUG_ENABLE="false"

pythonQEPest/__init__.py

@@ -0,0 +1,11 @@
+from pythonQEPest.core import QEPest
+from pythonQEPest.dto import QEPestData
+from pythonQEPest.dto import QEPestInput
+from pythonQEPest.dto import QEPestOutput
+
+__all__ = [
+    "QEPest",
+    "QEPestData",
+    "QEPestInput",
+    "QEPestOutput",
+]

pythonQEPest/cli/__init__.py

@@ -0,0 +1,7 @@
+def main():
+    from pythonQEPest.cli.cli import main as _main
+
+    return _main()
+
+
+__all__ = ["main"]

pythonQEPest/cli/cli.py

@@ -0,0 +1,101 @@
+from __future__ import annotations
+
+import argparse
+import logging
+from importlib.metadata import PackageNotFoundError, version
+from pathlib import Path
+from typing import Sequence
+
+from pythonQEPest.dto import QEPestFile
+from pythonQEPest.services.QEPestFileService import QEPestFileService
+
+logger = logging.getLogger(__name__)
+
+
+def _resolve_package_version() -> str:
+    try:
+        return version("pythonQEPest")
+    except PackageNotFoundError:
+        pass
+
+    try:
+        import tomllib  # py3.11+
+
+        pyproject = Path(__file__).resolve().parents[2] / "pyproject.toml"
+        data = tomllib.loads(pyproject.read_text(encoding="utf-8"))
+        return data["project"]["version"]
+    except Exception:
+        return "0+unknown"
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="pythonqepest",
+        description="Compute QEPest scores from a tab-separated input file.",
+    )
+    parser.add_argument(
+        "-v",
+        "--version",
+        action="version",
+        version=f"%(prog)s {_resolve_package_version()}",
+        help="Show program's version number.",
+    )
+    parser.add_argument(
+        "-i",
+        "--input",
+        default="data.txt",
+        help="Path to input tab-separated file with "
+        + "QEPest descriptors (default: data.txt).",
+    )
+
+    parser.add_argument(
+        "-o",
+        "--output",
+        default="data.out.txt",
+        help="Path to output tab-separated file with "
+        + "QEPest descriptors (default: data.txt.out).",
+    )
+
+    parser.add_argument(
+        "-f",
+        "--format",
+        default="txt",
+        help="Format to output file with QEPest (json, txt).",
+    )
+
+    parser.add_argument(
+        "--smiles",
+        action="store_true",
+        help="Input file contains SMILES strings "
+        "(one per line) instead of descriptors.",
+    )
+    return parser
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    from dotenv import load_dotenv
+
+    from pythonQEPest.core.qepest import QEPest
+    from pythonQEPest.logger import init_logger
+
+    args = build_parser().parse_args(argv)
+
+    load_dotenv()
+    init_logger()
+
+    logger.debug("CLI initiated")
+    logger.info(f"CLI args: {argv}")
+
+    service = QEPestFileService(
+        qepest=QEPest(),
+        qepest_file=QEPestFile(
+            input_file=args.input,
+            output_file=args.output,
+            format=args.format,
+            smiles=args.smiles,
+        ),
+    )
+
+    service.read_file_and_compute_params()
+
+    return 0 if not service.error else 1

pythonQEPest/config/__init__.py

@@ -0,0 +1,11 @@
+from pythonQEPest.config.qepest_default import qepest_default
+from pythonQEPest.config.normalise import normalise_default
+from pythonQEPest.config.qepest_config import QEPestConfig
+from pythonQEPest.config.config_provider import ConfigProvider
+
+__all__ = [
+    "normalise_default",
+    "qepest_default",
+    "ConfigProvider",
+    "QEPestConfig",
+]

pythonQEPest/config/config_provider.py

@@ -0,0 +1,9 @@
+from abc import ABC, abstractmethod
+
+from pythonQEPest.config.qepest_config import QEPestConfig
+
+
+class ConfigProvider(ABC):
+    @abstractmethod
+    def load(self) -> QEPestConfig:
+        pass

pythonQEPest/config/normalise.py

@@ -0,0 +1,12 @@
+normalise_default = {
+    "herb": (69.5849922, 94.4228257, 120.4572352, 228.1589796, 89.7012502, 276.9634213),
+    "insect": (
+        78.2919965,
+        71.2829691,
+        133.9224801,
+        331.170104,
+        70.5540709,
+        193.0023343,
+    ),
+    "fung": (53.3719946, 52.773116, 73.7976536, 144.9887053, 41.4385926, 102.3024319),
+}

pythonQEPest/config/qepest_config.py

@@ -0,0 +1,31 @@
+from typing import Optional
+
+from pydantic import BaseModel
+
+from pythonQEPest.dto.pest_type.PestTypeConfig import PestTypeConfig
+
+
+class QEPestConfig(BaseModel):
+    name: Optional[str] = "HerbInsectFung"
+    pest_types: list[PestTypeConfig]
+
+    def get_pest_names(self) -> list[str]:
+        return [pest.name for pest in self.pest_types]
+
+    def get_coefficients(
+        self, pest_name: str
+    ) -> list[tuple[float, float, float, float]]:
+        for pest in self.pest_types:
+            if pest.name == pest_name:
+                return pest.coefficients.as_set()
+
+        raise ValueError(f"Pest type '{pest_name}' not found")
+
+    def get_normaliser(
+        self, pest_name: str
+    ) -> tuple[float, float, float, float, float, float]:
+        for pest in self.pest_types:
+            if pest.name == pest_name:
+                return pest.normaliser
+
+        raise ValueError(f"Pest type '{pest_name}' not found")

pythonQEPest/config/qepest_default.py

@@ -0,0 +1,26 @@
+qepest_default = {
+    "herb": [
+        (70.77, 283.0, 84.97, -1.185),  # mwH
+        (93.81, 3.077, 1.434, 0.6164),  # logpH
+        (117.6, 2.409, 1.567, 7.155),  # hbaH
+        (233.4, 0.4535, -1.48, 4.47),  # hbdH
+        (84.7, 4.758, -2.423, 5.437),  # rbH
+        (301.8, 1.101, 0.8869, -22.81),  # arRCH
+    ],
+    "insect": [
+        (76.38, 298.3, 83.64, 1.912),  # mwI
+        (74.27, 4.555, -2.193, -2.987),  # logpI
+        (139.4, 1.363, 1.283, 0.5341),  # hbaI
+        (670.6, -1.163, 0.7856, 0.7951),  # hbdI
+        (65.49, 6.219, -2.448, 5.318),  # rbI
+        (287.5, 0.305, 1.554, -88.64),  # arRCI
+    ],
+    "fung": [
+        (51.03, 314.2, -56.31, 2.342),  # mwF
+        (50.73, 3.674, -1.238, 2.067),  # logpF
+        (73.79, 1.841, 1.326, 0.5158),  # hbaF
+        (164.7, -0.9762, -2.027, 1.384),  # hbdF
+        (40.91, 1.822, 2.582, 0.6235),  # rbF
+        (134.4, 0.8383, 1.347, -31.17),  # arRCF
+    ],
+}

pythonQEPest/core/__init__.py

@@ -0,0 +1,7 @@
+from .qepest import QEPest
+from .qepest_meta import QEPestMeta
+
+__all__ = [
+    "QEPestMeta",
+    "QEPest",
+]

pythonQEPest/core/qepest.py

@@ -0,0 +1,98 @@
+import logging
+import math
+from typing import Optional
+
+from pythonQEPest.config import ConfigProvider
+from pythonQEPest.core.qepest_meta import QEPestMeta
+from pythonQEPest.config.qepest_config import QEPestConfig
+from pythonQEPest.dto import QEPestData
+
+from pythonQEPest.dto.QEPestInput import QEPestInput
+from pythonQEPest.dto.QEPestOutput import QEPestOutput
+from pythonQEPest.dto.normalisation.Normaliser import Normaliser
+from pythonQEPest.helpers.check_nan import check_nan
+from pythonQEPest.helpers.compute_df import compute_df
+from pythonQEPest.helpers.get_values_from_line import get_values_from_line
+from pythonQEPest.helpers.round_to_4digs import round_to_4digs
+from pythonQEPest.providers import DefaultConfigProvider
+
+logger = logging.getLogger(__name__)
+
+
+class QEPest(QEPestMeta):
+    def __init__(self, provider: Optional[ConfigProvider] = None, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+        self.config: QEPestConfig
+        self.normalisers: dict[str, Normaliser] = {}
+        self.qex: QEPestData = QEPestData({})
+
+        logger.debug("QEPest initialization")
+
+        self.initialise_config(provider)
+
+        logger.debug("QEPest initialization successful")
+
+    def initialise_config(self, provider: Optional[ConfigProvider] = None):
+        logger.debug("Config initialisation")
+        if provider is None:
+            logger.debug("Config is empty. Loading default one.")
+            provider = DefaultConfigProvider()
+
+        self.config = provider.load()
+        logger.debug(f"Config {self.config} loaded")
+
+        for pest in self.config.pest_types:
+            self.normalisers[pest.name] = Normaliser(pest.normaliser)
+
+    def _log_compute_df(
+        self, func, index: int, lst: list[float], data_lst: list
+    ) -> float:
+        df_result = compute_df(lst[index], *data_lst[index])
+        return math.log(func(df_result, index))
+
+    def get_names(self) -> list[str]:
+        return self.config.get_pest_names()
+
+    def compute_params(self, data_input: QEPestInput) -> QEPestOutput:
+        self.get_qex_values(
+            get_values_from_line(list(data_input.model_dump().values()))
+        )
+        return QEPestOutput(data=self.qex, name=data_input.name)
+
+    def get_qex_values(self, d: list[float]) -> QEPestData:
+        names = self.get_names()
+
+        if len(names) == 0:
+            raise ValueError(
+                "No pest types configured. " "Please provide a valid configuration."
+            )
+
+        qe_values = dict.fromkeys(names, 0.0)
+
+        d_num = len(d)
+        for i in range(d_num):
+            for name in names:
+                coeffs = self.config.get_coefficients(name)
+                normaliser = self.normalisers[name]
+                qe_values[name] += self._log_compute_df(
+                    func=normaliser.norm,
+                    index=i,
+                    lst=d,
+                    data_lst=coeffs,
+                )
+
+        result = [round_to_4digs(math.exp(qe_values[name] / d_num)) for name in names]
+
+        result = check_nan(result)
+
+        self.qex = QEPestData(
+            {f"qe_{name}": result[idx] for idx, name in enumerate(names)}
+        )
+
+        return self.qex
+
+
+if __name__ == "__main__":
+    qepest = QEPest()
+    qepest.get_qex_values([1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0])

pythonQEPest/core/qepest_meta.py

@@ -0,0 +1,28 @@
+import os
+from abc import abstractmethod, ABC
+
+from pydantic import BaseModel
+
+from pythonQEPest.dto import QEPestInput, QEPestOutput
+
+
+class QEPestMeta(ABC):
+    def __init__(self, *args, **kwargs):
+        self.qex: BaseModel | None = None
+
+        self.col_number: int = 7
+        self.dir: str = os.getcwd()
+
+    @abstractmethod
+    def compute_params(self, data_input: QEPestInput) -> QEPestOutput:
+        pass
+
+    @abstractmethod
+    def get_qex_values(self, d: list[float]) -> None:
+        pass
+
+    @abstractmethod
+    def _log_compute_df(
+        self, func, index: int, lst: list[float], data_lst: list
+    ) -> float:
+        pass

pythonQEPest/data.txt

@@ -0,0 +1,2 @@
+Name	MW	LogP	HBA	HBD	RB	arR
+Nc1nc2CCCC3O[C@H](CCC)C(=O)c(n1)c23	247.29799999999994	1.8178	5	1	2	1

pythonQEPest/data.txt.out

@@ -0,0 +1,2 @@
+Name QEH QEI QEF
+Nc1nc2CCCC3O[C@H](CCC)C(=O)c(n1)c23 0.7387 0.4635 0.5941

pythonQEPest/dto/QEPestData.py

@@ -0,0 +1,21 @@
+from pydantic import RootModel, model_validator
+
+
+class QEPestData(RootModel[dict[str, float]]):
+    @model_validator(mode="before")
+    @classmethod
+    def handle_input(cls, data):
+        if data is None:
+            return {}
+        if isinstance(data, dict):
+            return data
+        return data
+
+    def __getattr__(self, name: str) -> float:
+        return self.root.get(name, 0.0)
+
+    def __setattr__(self, name: str, value: float) -> None:
+        if name == "root":
+            super().__setattr__(name, value)
+        else:
+            self.root[name] = value

pythonQEPest/dto/QEPestFile.py

@@ -0,0 +1,34 @@
+from enum import Enum
+from typing import Optional
+
+from pydantic import BaseModel, model_validator
+
+
+class QEPestFormat(Enum):
+    TXT = "txt"
+    JSON = "json"
+
+
+class QEPestFile(BaseModel):
+    input_file: Optional[str] = None
+    output_file: Optional[str] = None
+    format: Optional[QEPestFormat] = QEPestFormat.TXT
+    smiles: Optional[bool] = False
+
+    model_config = {"arbitrary_types_allowed": True}
+
+    @model_validator(mode="after")
+    def set_defaults(self):
+        if self.input_file is None:
+            self.input_file = "data.txt"
+
+        if self.format is None:
+            self.format = QEPestFormat.TXT
+
+        formatted_output = self.input_file.replace(".txt", "").replace(".json", "")
+        if self.format == QEPestFormat.JSON:
+            self.output_file = f"{formatted_output}.out.json"
+        else:
+            self.output_file = f"{formatted_output}.out.txt"
+
+        return self

pythonQEPest/dto/QEPestInput.py

@@ -0,0 +1,60 @@
+import logging
+from typing import Union
+
+from pydantic import BaseModel
+
+logger = logging.getLogger(__name__)
+
+
+class QEPestInput(BaseModel):
+    name: str = ""
+
+    mol_weight: float = 0.0
+    log_p: float = 0.0
+
+    hbond_acceptors: int = 0
+    hbond_donors: int = 0
+
+    rotatable_bonds: int = 0
+    aromatic_rings: int = 0
+
+    @classmethod
+    def from_array(cls, data: Union[list, tuple, set]):
+        if len(data) != 7:
+            raise ValueError(f"Expected 7 elements, got {len(data)}")
+        return cls(
+            name=data[0],
+            mol_weight=float(data[1]),
+            log_p=float(data[2]),
+            hbond_acceptors=int(data[3]),
+            hbond_donors=int(data[4]),
+            rotatable_bonds=int(data[5]),
+            aromatic_rings=int(data[6]),
+        )
+
+    @classmethod
+    def from_smiles(cls, smiles: str, name: str = ""):
+        try:
+            from rdkit import Chem
+            from rdkit.Chem import Descriptors
+        except ImportError:
+            logger.warning(
+                "RDKit is not installed. Install it with: poetry install --with rdkit. "
+                "Returning QEPestInput with default values."
+            )
+            return cls(name=name)
+
+        mol = Chem.MolFromSmiles(smiles)
+
+        if mol is None:
+            raise ValueError(f"Invalid SMILES: {smiles}")
+
+        return cls(
+            name=name,
+            mol_weight=Descriptors.ExactMolWt(mol),
+            log_p=Descriptors.MolLogP(mol),
+            hbond_acceptors=Descriptors.NumHAcceptors(mol),
+            hbond_donors=Descriptors.NumHDonors(mol),
+            rotatable_bonds=Descriptors.NumRotatableBonds(mol),
+            aromatic_rings=Descriptors.NumAromaticRings(mol),
+        )

pythonQEPest/dto/QEPestOutput.py

@@ -0,0 +1,13 @@
+from typing import Optional
+
+from pydantic import BaseModel
+from pythonQEPest.dto.QEPestData import QEPestData
+
+
+class QEPestOutput(BaseModel):
+    data: QEPestData
+    name: Optional[str] = ""
+
+    def to_array(self) -> list:
+        values = list(self.data.root.values())
+        return [self.name] + values

pythonQEPest/dto/__init__.py

@@ -0,0 +1,27 @@
+from pythonQEPest.dto.QEPestData import QEPestData
+from pythonQEPest.dto.QEPestInput import QEPestInput
+from pythonQEPest.dto.QEPestFile import QEPestFile, QEPestFormat
+from pythonQEPest.dto.QEPestOutput import QEPestOutput
+
+from pythonQEPest.dto.coefficients import QEPestCoefficient
+from pythonQEPest.dto.coefficients import QEPestCoefficientList
+from pythonQEPest.dto.coefficients import QEPestCoefficientNumerics
+
+from pythonQEPest.dto.normalisation import Normaliser
+
+from pythonQEPest.dto.pest_type.PestTypeCoefficient import PestTypeCoefficient
+from pythonQEPest.dto.pest_type.PestTypeConfig import PestTypeConfig
+
+__all__ = [
+    "QEPestOutput",
+    "QEPestData",
+    "QEPestInput",
+    "QEPestFile",
+    "QEPestFormat",
+    "PestTypeConfig",
+    "PestTypeCoefficient",
+    "Normaliser",
+    "QEPestCoefficientNumerics",
+    "QEPestCoefficientList",
+    "QEPestCoefficient",
+]

pythonQEPest/dto/coefficients/QEPestCoefficient.py

@@ -0,0 +1,57 @@
+from pydantic import BaseModel
+
+from pythonQEPest.dto.coefficients import QEPestCoefficientNumerics
+
+
+class QEPestCoefficient(BaseModel):
+    name: str
+    coefficients: QEPestCoefficientNumerics
+
+    def __init__(self, *args, **kwargs):
+        if args:
+            if len(args) != 1:
+                raise ValueError(f"Expected len(args) == 1, got {len(args)}")
+
+            # In case of {"test": [[1,2,3,4],[1,2,3,4],[1,2,3,4]}
+            if len(args[0]) == 1:
+                must_be_dict = args[0]
+                if isinstance(must_be_dict, dict):
+                    key = list(must_be_dict.keys())[0]
+                    coefficients = QEPestCoefficientNumerics(must_be_dict[key])
+                    super().__init__(name=key, coefficients=coefficients)
+
+            # In case of ["test", [[1,2,3,4],[1,2,3,4],[1,2,3,4]]
+            elif len(args[0]) == 2:
+                arr = args[0]
+                if (
+                    isinstance(arr, tuple)
+                    or isinstance(arr, set)
+                    or isinstance(arr, list)
+                ):
+                    name = arr[0]
+                    coefficients = QEPestCoefficientNumerics(arr[1])
+                    super().__init__(name=name, coefficients=coefficients)
+
+        elif kwargs:
+            super().__init__(**kwargs)
+        else:
+            raise ValueError(
+                "No name and coefficients provided. Please provide either a "
+                + "name and coefficients tuple or keyword arguments."
+            )
+
+
+if __name__ == "__main__":
+    # Example usage
+    coefficients = QEPestCoefficient(
+        mw=[0.1, 0.2, 0.3, 0.4],
+        logp=[0.1, 0.2, 0.3, 0.4],
+        hba=[0.1, 0.2, 0.3, 0.4],
+        hbd=[0.1, 0.2, 0.3, 0.4],
+        rb=[0.1, 0.2, 0.3, 0.4],
+        ar=[0.1, 0.2, 0.3, 0.4],
+    )
+    print(coefficients)
+
+    coefficients_alternative = QEPestCoefficient([[0.1, 0.2, 0.3, 0.4] * 6])
+    print(coefficients_alternative)

pythonQEPest/dto/coefficients/QEPestCoefficientList.py

@@ -0,0 +1,29 @@
+from typing import Optional, List
+
+from pydantic import BaseModel
+
+from pythonQEPest.dto.coefficients import QEPestCoefficient
+
+
+class QEPestCoefficientList(BaseModel):
+    name: Optional[str]
+    named_coefficients: List[QEPestCoefficient]
+
+    # TODO: Done all the cases and make some sort of docs here, pls
+    def __init__(self, *args, **kwargs):
+        if args:
+            named_coeff = args[0]
+            if len(named_coeff) == 1:
+                pass
+            elif len(named_coeff) > 1:
+                if isinstance(named_coeff, dict):
+                    lst = [QEPestCoefficient({i: z}) for i, z in named_coeff.items()]
+                    super().__init__(name="generic", named_coefficients=lst)
+
+        elif kwargs:
+            super().__init__(**kwargs)
+        else:
+            raise ValueError(
+                "No name and coefficients provided. Please provide either a "
+                + "name and coefficients tuple or keyword arguments."
+            )

pythonQEPest/dto/coefficients/QEPestCoefficientNumerics.py

@@ -0,0 +1,44 @@
+from pydantic import BaseModel
+
+CoefficientTuple = tuple[float, float, float, float]
+
+
+class QEPestCoefficientNumerics(BaseModel):
+    mw: CoefficientTuple
+    logp: CoefficientTuple
+    hba: CoefficientTuple
+    hbd: CoefficientTuple
+    rb: CoefficientTuple
+    ar: CoefficientTuple
+
+    def __init__(self, *args, **kwargs):
+        if args:
+            # In case of [[1,2,3,4],[1,2,3,4],[1,2,3,4]]
+            # I don't want it to be a pain to init D:
+            if len(args) != 1:
+                raise ValueError(
+                    f"Expected a single list of coefficients, got {len(args)}"
+                )
+
+            coefficients = args[0]
+            if len(coefficients) != 6:
+                raise ValueError(
+                    "Expected list with structure [[1,2,3,4,5,6], ",
+                    "[1,2,3,4,5,6], [1,...] ...] got ",
+                    f"{len(coefficients)} and {coefficients}",
+                )
+
+            coefficients_mapped = {
+                field: coefficients[i]
+                for i, field in enumerate(["mw", "logp", "hba", "hbd", "rb", "ar"])
+            }
+            super().__init__(**coefficients_mapped)
+
+        elif kwargs:
+            super().__init__(**kwargs)
+
+        else:
+            raise ValueError(
+                "No coefficients provided. Please provide either a ",
+                "list of coefficient tuples or keyword arguments.",
+            )

pythonQEPest/dto/coefficients/__init__.py

@@ -0,0 +1,7 @@
+from pythonQEPest.dto.coefficients.QEPestCoefficientNumerics import (
+    QEPestCoefficientNumerics,
+)
+from pythonQEPest.dto.coefficients.QEPestCoefficient import QEPestCoefficient
+from pythonQEPest.dto.coefficients.QEPestCoefficientList import QEPestCoefficientList
+
+__all__ = ["QEPestCoefficientNumerics", "QEPestCoefficient", "QEPestCoefficientList"]