pythonQEPest 2.0.0a2__py3-none-any.whl

pythonQEPest/gui/gui_meta.py

@@ -0,0 +1,17 @@
+from abc import ABC, abstractmethod
+
+from pythonQEPest.core.qepest import QEPest
+
+
+class QEPestMeta(ABC):
+    def __init__(self, root):
+        self.root = root
+        self.root.title("PythonQEPest")
+
+        self.qepest = QEPest()
+
+        self.build_gui()
+
+    @abstractmethod
+    def build_gui(self):
+        pass

pythonQEPest/gui/utility/DataManager.py

@@ -0,0 +1,76 @@
+from pythonQEPest.gui.utility.DataManagerMeta import DataManagerMeta
+
+
+class DataManager(metaclass=DataManagerMeta):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._file_data = []
+        self._result_data = []
+
+    # def __call__(self, *args, **kwargs) -> list:
+    #     return self.file_data
+
+    # def __bool__(self):
+    #     return bool(self.file_data)
+
+    @property
+    def file_data(self):
+        return self._file_data
+
+    @property
+    def result_data(self):
+        return self._result_data
+
+    def clear(self, lst):
+        lst.clear()
+        return self
+
+    def add(self, lst, entry):
+        if not entry in lst:
+            lst.append(entry)
+        return self
+
+    def update(self, lst, index, new_entry):
+        if 0 <= index < len(lst):
+            lst[index] = new_entry
+        return self
+
+    def remove_by_id(self, lst, id: str | int):
+        return [row for row in lst if row[0] != id]
+
+    def remove_by_ids(self, lst, ids: list[str, int]):
+        return [row for row in lst if row[0] not in ids]
+
+    def clear_file(self):
+        return self.clear(self.file_data)
+
+    def add_file(self, entry):
+        return self.add(self.file_data, entry)
+
+    def update_file(self, index, new_entry):
+        return self.update(self.file_data, index, new_entry)
+
+    def remove_file_by_id(self, id: str | int):
+        self._file_data = self.remove_by_id(self.file_data, id)
+        return self
+
+    def remove_file_by_ids(self, ids: list[str, int]):
+        self._file_data = self.remove_by_ids(self.file_data, ids)
+        return self
+
+    def clear_result(self):
+        return self.clear(self.result_data)
+
+    def add_result(self, entry):
+        return self.add(self.result_data, entry)
+
+    def update_result(self, index, new_entry):
+        return self.update(self.result_data, index, new_entry)
+
+    def remove_result_by_id(self, id: str | int):
+        self._result_data = self.remove_by_id(self.result_data, id)
+        return self
+
+    def remove_result_by_ids(self, ids: list[str, int]):
+        self._result_data = self.remove_by_ids(self.result_data, ids)
+        return self

pythonQEPest/gui/utility/DataManagerMeta.py

@@ -0,0 +1,8 @@
+class DataManagerMeta(type):
+    _instances = {}
+
+    def __call__(cls, *args, **kwargs):
+        if cls not in cls._instances:
+            instance = super().__call__(*args, **kwargs)
+            cls._instances[cls] = instance
+        return cls._instances[cls]

pythonQEPest/gui/utility/__init__.py

@@ -0,0 +1,6 @@
+from pythonQEPest.gui.utility import DataManager, DataManagerMeta
+
+__all__ = [
+    "DataManager",
+    "DataManagerMeta",
+]

pythonQEPest/helpers/__init__.py

@@ -0,0 +1,17 @@
+from pythonQEPest.helpers.check_nan import check_nan
+from pythonQEPest.helpers.compute_df import compute_df
+from pythonQEPest.helpers.get_num_of_cols import get_num_of_cols
+from pythonQEPest.helpers.get_values_from_line import get_values_from_line
+from pythonQEPest.helpers.norm import norm_h, norm_f, norm_i
+from pythonQEPest.helpers.round_to_4digs import round_to_4digs
+
+__all__ = [
+    "check_nan",
+    "compute_df",
+    "get_num_of_cols",
+    "get_values_from_line",
+    "norm_h",
+    "norm_f",
+    "norm_i",
+    "round_to_4digs",
+]

pythonQEPest/helpers/check_nan.py

@@ -0,0 +1,8 @@
+import math
+
+
+def check_nan(d) -> list[float]:
+    for i in range(len(d)):
+        if math.isnan(d[i]):
+            d[i] = 0.0
+    return d

pythonQEPest/helpers/compute_df.py

@@ -0,0 +1,5 @@
+import math
+
+
+def compute_df(x, a, b, c, o) -> float:
+    return a * math.exp(-1.0 * math.exp(-1.0 * ((x - b) / c)) - (x - b) / c + 1.0) + o

pythonQEPest/helpers/get_num_of_cols.py

@@ -0,0 +1,2 @@
+def get_num_of_cols(h: str) -> int:
+    return len(h.split("\t"))

pythonQEPest/helpers/get_values_from_line.py

@@ -0,0 +1,5 @@
+from typing import Union
+
+
+def get_values_from_line(lst: Union[list, tuple, set]) -> list[float]:
+    return [float(x) for x in lst[1:]]

pythonQEPest/helpers/norm.py

@@ -0,0 +1,33 @@
+from typing import Union
+
+
+def norm(arr: Union[list, tuple], d: Union[int, float], descr: int) -> float:
+    if descr > len(arr):
+        raise KeyError(f"Out of array. {descr} > {len(arr)}")
+
+    max_val = arr[int(descr)]
+    return d / max_val if max_val != 0 else 0.0
+
+
+def norm_h(d: Union[int, float], descr: int) -> float:
+    return norm(
+        (69.5849922, 94.4228257, 120.4572352, 228.1589796, 89.7012502, 276.9634213),
+        d,
+        descr,
+    )
+
+
+def norm_i(d: Union[int, float], descr: int) -> float:
+    return norm(
+        (78.2919965, 71.2829691, 133.9224801, 331.170104, 70.5540709, 193.0023343),
+        d,
+        descr,
+    )
+
+
+def norm_f(d: Union[int, float], descr: int) -> float:
+    return norm(
+        (53.3719946, 52.773116, 73.7976536, 144.9887053, 41.4385926, 102.3024319),
+        d,
+        descr,
+    )

pythonQEPest/helpers/round_to_4digs.py

@@ -0,0 +1,2 @@
+def round_to_4digs(q) -> float:
+    return float("{:.4f}".format(q))

pythonQEPest/logger.py

@@ -0,0 +1,58 @@
+import logging
+import os
+from logging.handlers import RotatingFileHandler
+from pathlib import Path
+
+
+def init_logger() -> None:
+    # If debug mode is enabled, we want to log everything, otherwise we can skip logging
+    if os.getenv("APP_DEBUG_ENABLE", "true").lower() == "false":
+        return
+
+    root_logger = logging.getLogger("pythonQEPest")
+
+    log_file: str = os.getenv("LOG_FILE_LOCATION", "logs/app.log")
+    level = os.getenv("LOG_LEVEL", "INFO").upper()
+
+    match level:
+        case "DEBUG":
+            level = logging.DEBUG
+        case "INFO":
+            level = logging.INFO
+        case "WARNING":
+            level = logging.WARNING
+        case "ERROR":
+            level = logging.ERROR
+        case _:
+            level = logging.INFO
+
+    if root_logger.handlers:
+        return
+
+    log_path = Path(log_file)
+    log_path.parent.mkdir(parents=True, exist_ok=True)
+
+    formatter = logging.Formatter(
+        fmt="%(asctime)s %(levelname)s %(name)s: %(message)s",
+        datefmt="%Y-%m-%d %H:%M:%S",
+    )
+
+    file_handler = RotatingFileHandler(
+        log_path,
+        maxBytes=1_000_000,
+        backupCount=3,
+        encoding="utf-8",
+    )
+    file_handler.setLevel(level)
+    file_handler.setFormatter(formatter)
+
+    console_handler = logging.StreamHandler()
+    console_handler.setLevel(level)
+    console_handler.setFormatter(formatter)
+
+    root_logger.setLevel(level)
+    root_logger.addHandler(file_handler)
+    root_logger.addHandler(console_handler)
+
+    root_logger.info("Logger started Successfully")
+    root_logger.info(f"Level: {level}")

pythonQEPest/main.py

@@ -0,0 +1,4 @@
+from pythonQEPest.cli.cli import main
+
+if __name__ == "__main__":
+    raise SystemExit(main())

pythonQEPest/providers/__init__.py

@@ -0,0 +1,6 @@
+from pythonQEPest.providers.default_provider import DefaultConfigProvider
+
+__all__ = [
+    "DefaultConfigProvider",
+    "JSONConfigProvider",
+]

pythonQEPest/providers/default_provider.py

@@ -0,0 +1,23 @@
+from pythonQEPest.config.config_provider import ConfigProvider
+from pythonQEPest.config.qepest_config import QEPestConfig, PestTypeConfig
+from pythonQEPest.dto import PestTypeCoefficient
+
+
+class DefaultConfigProvider(ConfigProvider):
+    def load(self) -> QEPestConfig:
+        from pythonQEPest.config.qepest_default import qepest_default
+        from pythonQEPest.config.normalise import normalise_default
+
+        pest_types = []
+        for pest_name in qepest_default.keys():
+            pest_types.append(
+                PestTypeConfig(
+                    name=pest_name,
+                    coefficients=PestTypeCoefficient.model_validate(
+                        qepest_default[pest_name]
+                    ),
+                    normaliser=normalise_default[pest_name],
+                )
+            )
+
+        return QEPestConfig(pest_types=pest_types)

pythonQEPest/providers/json_provider.py

@@ -0,0 +1,30 @@
+import json
+from pathlib import Path
+
+from pythonQEPest.config.config_provider import ConfigProvider
+from pythonQEPest.config.qepest_config import QEPestConfig, PestTypeConfig
+
+
+class JSONConfigProvider(ConfigProvider):
+    def load(self, path: str | Path) -> QEPestConfig:
+        path = Path(path)
+
+        with open(path, encoding="utf-8") as f:
+            data = json.load(f)
+
+        return self.load_raw_json(data)
+
+    def load_raw_json(self, data):
+        pest_types = []
+        for pest_name, pest_data in data.items():
+            coefficients = [tuple(coef) for coef in pest_data["coefficients"]]
+            normaliser = tuple(pest_data["normaliser"])
+            pest_types.append(
+                PestTypeConfig(
+                    name=pest_name,
+                    coefficients=coefficients,
+                    normaliser=normaliser,
+                )
+            )
+
+        return QEPestConfig(pest_types=pest_types)

pythonQEPest/providers/txt_provider.py

@@ -0,0 +1,46 @@
+from pathlib import Path
+
+from pythonQEPest.config.config_provider import ConfigProvider
+from pythonQEPest.config.qepest_config import QEPestConfig, PestTypeConfig
+
+
+class TXTConfigProvider(ConfigProvider):
+    def __init__(self, path: str | Path):
+        self.path = Path(path)
+
+    def load(self) -> QEPestConfig:
+        with open(self.path, encoding="utf-8") as f:
+            lines = f.readlines()
+
+        pest_types_dict: dict[str, dict] = {}
+        current_pest = None
+
+        for line in lines:
+            line = line.strip()
+            if not line or line.startswith("#"):
+                continue
+
+            if line.startswith("[") and line.endswith("]"):
+                current_pest = line[1:-1]
+                pest_types_dict[current_pest] = {"coefficients": [], "normaliser": []}
+            elif current_pest and "=" in line:
+                key, value = line.split("=", 1)
+                if key.strip() == "coefficients":
+                    parts = [float(x.strip()) for x in value.strip().split(",")]
+                    for i in range(0, len(parts), 4):
+                        pest_types_dict[current_pest]["coefficients"].append(
+                            tuple(parts[i:i + 4])
+                        )
+                elif key.strip() == "normaliser":
+                    parts = [float(x.strip()) for x in value.strip().split(",")]
+                    pest_types_dict[current_pest]["normaliser"] = tuple(parts)
+
+        pest_types = []
+        for pest_name, pest_data in pest_types_dict.items():
+            pest_types.append(PestTypeConfig(
+                name=pest_name,
+                coefficients=pest_data["coefficients"],
+                normaliser=tuple(pest_data["normaliser"]),
+            ))
+
+        return QEPestConfig(pest_types=pest_types)

pythonQEPest/services/QEPestFileService.py

@@ -0,0 +1,125 @@
+import logging
+import json
+
+from pythonQEPest.core import QEPestMeta
+from pythonQEPest.dto import QEPestFile, QEPestInput
+from pythonQEPest.dto.QEPestFile import QEPestFormat
+from pythonQEPest.helpers.get_values_from_line import get_values_from_line
+from pythonQEPest.helpers.get_num_of_cols import get_num_of_cols
+
+logger = logging.getLogger(__name__)
+
+
+class QEPestFileService:
+
+    def __init__(self, qepest: QEPestMeta, qepest_file: QEPestFile):
+        self.qepest = qepest
+        self.qepest_file = qepest_file
+        self.error = False
+
+    def _write_txt_line(self, line: str, file) -> None:
+        splitted_line = line.split("\t")[0]
+        qex_headers = " ".join(self.qepest.qex.model_dump().keys())
+        qex_values = " ".join(str(x) for x in self.qepest.qex.model_dump().values())
+
+        file.write(f"Name {qex_headers.upper()}\n")
+        file.write(f"{splitted_line} {qex_values}\n")
+
+    def _write_json_line(self, line: str, file) -> None:
+        splitted_line = line.split("\t")[0]
+        data = {"name": splitted_line, **self.qepest.qex.model_dump()}
+        file.write(json.dumps(data) + "\n")
+
+    def _process_smiles_line(self, smiles: str, index: int) -> None:
+        qepest_input = QEPestInput.from_smiles(smiles, name=f"mol_{index}")
+        if qepest_input.mol_weight == 0.0:
+            raise RuntimeError(
+                "RDKit is not installed. Install it with: pip install rdkit"
+            )
+        d_values = get_values_from_line(list(qepest_input.model_dump().values()))
+        self.qepest.get_qex_values(d_values)
+
+    def _write_smiles_txt_line(self, index: int, file) -> None:
+        name = f"mol_{index}"
+        qex_headers = " ".join(self.qepest.qex.model_dump().keys())
+        qex_values = " ".join(str(x) for x in self.qepest.qex.model_dump().values())
+        file.write(f"Name {qex_headers.upper()}\n")
+        file.write(f"{name} {qex_values}\n")
+
+    def _write_smiles_json_line(self, index: int, file) -> None:
+        name = f"mol_{index}"
+        data = {"name": name, **self.qepest.qex.model_dump()}
+        file.write(json.dumps(data) + "\n")
+
+    def read_file_and_compute_params(self) -> None:
+        if self.qepest_file.smiles:
+            self._read_smiles_file()
+        else:
+            self._read_descriptor_file()
+
+    def _read_smiles_file(self) -> None:
+        try:
+            with open(self.qepest_file.input_file, "r") as f:
+                lines = f.readlines()
+
+            with open(self.qepest_file.output_file, "w") as wr:
+                for index, line in enumerate(lines):
+                    smiles = line.strip()
+                    if not smiles:
+                        continue
+
+                    try:
+                        self._process_smiles_line(smiles, index)
+                    except RuntimeError as e:
+                        logger.error(str(e))
+                        self.error = True
+                        break
+
+                    if self.qepest_file.format == QEPestFormat.TXT:
+                        self._write_smiles_txt_line(index, wr)
+                    else:
+                        self._write_smiles_json_line(index, wr)
+
+            if not self.error:
+                logger.info("Computation completed")
+            else:
+                logger.warning("Finished with errors")
+
+        except FileNotFoundError:
+            self.error = True
+            logger.error(f"Error: can't find: {self.qepest_file.input_file}")
+
+    def _read_descriptor_file(self) -> None:
+        try:
+            with open(self.qepest_file.input_file, "r") as f:
+                lines = f.readlines()
+
+            with open(self.qepest_file.output_file, "w") as wr:
+                for index, line in enumerate(lines):
+                    if get_num_of_cols(line) != self.qepest.col_number:
+                        logger.error(
+                            f"Error: Line {index} does not have the "
+                            "expected number of columns."
+                        )
+                        self.error = True
+                        break
+
+                    if index == 0:
+                        continue
+
+                    d_values = get_values_from_line(line.split("\t"))
+                    self.qepest.get_qex_values(d_values)
+
+                    if self.qepest_file.format == QEPestFormat.TXT:
+                        self._write_txt_line(line, wr)
+                    else:
+                        self._write_json_line(line, wr)
+
+            if not self.error:
+                logger.info("Computation completed")
+            else:
+                logger.warning("Finished with errors")
+
+        except FileNotFoundError:
+            self.error = True
+            logger.error(f"Error: can't find: {self.qepest_file.input_file}")

pythonQEPest/services/__init__.py

@@ -0,0 +1,3 @@
+from pythonQEPest.services.QEPestFileService import QEPestFileService
+
+__all__ = ["QEPestFileService"]