pyThermoDB 1.0.0__py3-none-any.whl

pyThermoDB/__init__.py

@@ -0,0 +1,55 @@
+from .config import __version__, __author__, __description__
+from .core import (
+    TableEquation,
+    TableMatrixEquation,
+    TableData,
+    TableMatrixData
+)
+from .docs import ThermoDB
+from .builder import CompBuilder
+from .loader import CustomRef
+from .manager import ManageData
+from .app import (
+    init,
+    ref,
+    build_thermodb,
+    load_thermodb,
+)
+from .thermodb import (
+    build_component_thermodb,
+    build_components_thermodb,
+    build_component_thermodb_from_reference,
+    check_and_build_component_thermodb,
+    check_and_build_components_thermodb,
+    build_mixture_thermodb_from_reference,
+    check_and_build_mixture_thermodb,
+    ComponentThermoDB,
+    MixtureThermoDB
+)
+
+__all__ = [
+    '__version__',
+    '__author__',
+    '__description__',
+    'ThermoDB',
+    'CompBuilder',
+    'TableData',
+    'TableEquation',
+    'TableMatrixData',
+    'TableMatrixEquation',
+    'init',
+    'ref',
+    'build_thermodb',
+    'load_thermodb',
+    'build_component_thermodb',
+    'build_components_thermodb',
+    'ManageData',
+    'CustomRef',
+    'build_component_thermodb_from_reference',
+    'check_and_build_component_thermodb',
+    'check_and_build_components_thermodb',
+    'build_mixture_thermodb_from_reference',
+    'check_and_build_mixture_thermodb',
+    'ComponentThermoDB',
+    'MixtureThermoDB'
+]

pyThermoDB/api/__init__.py

@@ -0,0 +1 @@
+from .manage import Manage

pyThermoDB/api/manage.py

@@ -0,0 +1,68 @@
+# import packages/modules
+# externals
+import requests
+# internal
+
+
+class Manage:
+    def __init__(self, api_url, databook_id, table_id):
+        self.api_url = api_url
+        self.databook_id = databook_id
+        self.table_id = table_id
+
+    def component_list(self) -> list:
+        # parameters
+        reqtype = 'read'
+        id = str(self.databook_id).strip()
+        fid = str(self.table_id).strip()
+        parameters = f"?reqtype={reqtype}&id={id}&fid={fid}"
+        # all data
+        get_all = self.api_url + parameters
+        response = requests.get(get_all)
+
+        if response.status_code == 200:
+            payload = response.json()
+            data = payload['records']
+            # header
+            header = data[0]
+            # records
+            records = data[1:]
+            # find the index
+            for i, item in enumerate(header):
+                if item.lower() == "name":
+                    name_id = int(i)
+            # component names
+            component_names = [record[name_id] for record in records]
+            return component_names
+        else:
+            print("error", response.status_code)
+            return []
+
+    def component_info(self, component_name: str, search_col_name="Name"):
+        '''
+        get component info
+        '''
+        # parameters
+        reqtype = 'search'
+        id = str(self.databook_id).strip()
+        fid = str(self.table_id).strip()
+        # query
+        query = {
+            "reqtype": reqtype,
+            "id": id,
+            "fid": fid,
+            "search_col_name": search_col_name,
+            "name": component_name
+        }
+
+        # post
+        response = requests.post(self.api_url, json=query, headers={
+                                 "Content-Type": "application/json"})
+
+        if response.status_code == 200:
+            payload = response.json()
+            data = payload
+            return data
+        else:
+            print("error", response.status_code)
+            return []

pyThermoDB/app.py

@@ -0,0 +1,212 @@
+# import packages/modules
+import logging
+import os
+from typing import (
+    Optional,
+    Dict,
+    List,
+)
+# local
+from .docs import (
+    ThermoDB,
+    TableReference,
+)
+from .builder import CompBuilder
+from .loader import CustomRef
+from .models import CustomReference
+
+
+# NOTE: logger
+logger = logging.getLogger(__name__)
+
+
+def init(
+    custom_reference: Optional[
+        CustomReference | str
+    ] = None
+) -> ThermoDB:
+    '''
+    Initialize thermodb app to check and build thermodynamic data and equations.
+
+    Parameters
+    ----------
+    custom_reference : Optional[CustomReference | str], optional
+        set-up external reference (custom reference) dict for databook and tables (check examples)
+
+    Returns
+    -------
+    ThermoDB : object
+        ThermoDB object used for checking and building data and equation objects
+
+    Notes
+    ------
+    ### Set-up external reference dict for databook and tables
+
+    - `format ref_external = {'reference':[yml files], 'tables':[csv files]}`
+
+    ### Examples
+
+    ```python
+    # custom ref
+    custom_reference = {
+    'reference': [yml_path],
+    'tables': [csv_path_1, csv_path_2]
+    }
+
+    # init app
+    tdb = ptdb.init(custom_reference=custom_reference)
+    ```
+    '''
+    try:
+        # NOTE: init vars
+        # check new custom ref
+        check_ref = False
+        # init class
+        CustomRefC = None
+
+        # SECTION: init class
+        if custom_reference:
+            # NOTE: check both str and dict
+            if not isinstance(custom_reference, (str, dict)):
+                logger.error(
+                    "`custom_reference` must be a string or dictionary!")
+                raise TypeError(
+                    "`custom_reference` must be a string or dictionary!")
+
+            # NOTE: check if string (yml file)
+            if isinstance(custom_reference, str):
+                # set dict
+                custom_reference = {'reference': [custom_reference]}
+
+            # NOTE: check dict values
+            if not all(isinstance(v, list) for v in custom_reference.values()):
+                logger.error(
+                    "All values in `custom_reference` dictionary must be lists!")
+                raise TypeError(
+                    "All values in `custom_reference` dictionary must be lists!")
+
+            # NOTE: init class
+            CustomRefC = CustomRef(custom_reference)
+
+            # NOTE: initialize reference
+            check_ref = CustomRefC.init_ref()
+
+        # SECTION: check ref
+        if check_ref:
+            return ThermoDB(custom_ref=CustomRefC)
+        else:
+            return ThermoDB()
+    except Exception as e:
+        raise Exception(f"Initializing app failed! {e}")
+
+
+def ref(
+    custom_reference: Optional[
+        Dict[str, List[str]]
+    ] = None
+) -> TableReference:
+    '''
+    Checking references (custom reference) object including databook and tables to display data
+
+    Parameters
+    ----------
+    custom_reference : dict
+        set-up external reference dict for databook and tables, format `ref_external = {'yml':[yml files], 'csv':[csv files]}`
+
+    Returns
+    -------
+    TableReferenceC : object
+        TableReference object used for checking references
+
+    Notes
+    ------
+    ### Check external reference dict for databook and tables
+
+    - `format ref_external = {'yml':[yml files], 'csv':[csv files]}`
+    - `format ref_external = {'reference':[yml files], 'tables':[csv files]}`
+
+    ### Examples
+
+    ```python
+    # custom ref
+    custom_reference = {
+    'reference': [yml_path],
+    'tables': [csv_path_1, csv_path_2]
+    }
+
+    # init app
+    tdb = ptdb.ref(custom_reference=custom_reference)
+    ```
+    '''
+    try:
+        # check new custom ref
+        check_ref = False
+        if custom_reference:
+            CustomRefC = CustomRef(custom_reference)
+            # check ref
+            check_ref = CustomRefC.init_ref()
+
+        # check
+        if check_ref:
+            return TableReference(custom_ref=CustomRefC)
+        else:
+            # init
+            return TableReference()
+
+    except Exception as e:
+        raise Exception(f'Building reference failed! {e}')
+
+
+def build_thermodb(
+    thermodb_name: Optional[str] = None,
+    message: Optional[str] = None
+) -> CompBuilder:
+    '''
+    Build thermodb object to check and build thermodynamic data and equations
+
+    Parameters
+    ----------
+    thermodb_name : str
+        name of the thermodb object
+        - `thermodb_name` : str, name of the thermodb object
+    message : str, optional
+        a short description of the thermodb object, by default None
+
+    Returns
+    -------
+    CompBuilder : object
+        CompBuilder object used for building thermodynamic data and equations
+    '''
+    try:
+        # NOTE: init class
+        return CompBuilder(
+            thermodb_name=thermodb_name,
+            message=message
+        )
+    except Exception as e:
+        raise Exception("Building thermodb failed!, ", e)
+
+
+def load_thermodb(thermodb_file: str) -> CompBuilder:
+    '''
+    Load thermodb object to read thermodynamic data and equations
+
+    Parameters
+    ----------
+    thermodb_file : str
+        thermodb filename path
+
+    Returns
+    -------
+    CompBuilder : object
+        CompBuilder object used for loading thermodynamic data and equations
+    '''
+    try:
+        # NOTE: check file exists
+        if not os.path.isfile(thermodb_file):
+            raise FileNotFoundError(f"File '{thermodb_file}' does not exist!")
+
+        # NOTE: init class
+        return CompBuilder.load(thermodb_file)
+    except Exception as e:
+        raise Exception("Loading thermodb failed!, ", e)

pyThermoDB/builder/__init__.py

@@ -0,0 +1,6 @@
+# export
+from .compbuilder import CompBuilder
+
+__all_ = [
+    'CompBuilder',
+]

pyThermoDB/builder/comp_tools.py

@@ -0,0 +1,174 @@
+# import libs
+import logging
+from typing import List, Dict, Any, Optional
+# local
+from pyThermoDB.core import TableEquation, TableData
+from ..references.symbols_controller import SymbolController
+
+# NOTE: logger
+logger = logging.getLogger(__name__)
+
+
+class CompTools:
+    """
+    Component Tools for handling thermodynamic data and functions (equations).
+    """
+
+    def __init__(self):
+        # LINK: Initialize SymbolController
+        self.symbol_controller = SymbolController()
+
+    def get_fn_structure(
+            self,
+            func: List[TableEquation]
+    ):
+        try:
+            # NOTE: init
+            res: Dict[str, Any] = {}
+
+            for fn in func:
+                # get info
+                db_name = fn.databook_name
+                tb_name = fn.table_name
+                eq_number = fn.eq_num
+                returns = fn.returns
+                return_symbols = fn.return_symbols
+                return_identifiers = fn.make_identifiers(
+                    param_id="return",
+                    mode="symbol"
+                )
+                args = fn.args
+                arg_symbols = fn.arg_symbols
+                arg_identifiers = fn.make_identifiers(
+                    param_id="arg",
+                    mode="symbol"
+                )
+                fn_body = fn.body
+                fn_body_integral = fn.body_integral
+
+                # set id
+                fn_id = f"{db_name}::{tb_name}"
+
+                # build structure
+                res[fn_id] = {
+                    "function_numbers": eq_number,
+                    "returns": returns,
+                    "return_symbols": return_symbols,
+                    "return_identifiers": return_identifiers,
+                    "args": args,
+                    "arg_symbols": arg_symbols,
+                    "arg_identifiers": arg_identifiers,
+                    "function_body": fn_body,
+                    "function_body_integral": fn_body_integral
+                }
+
+            return res
+        except Exception as e:
+            logger.error(f"Error in getting functions' structure: {e}")
+            return None
+
+    def get_fn_identifier(
+            self,
+            func: List[TableEquation]
+    ) -> Optional[List[Dict[str, str]]]:
+        try:
+            res = [
+                {
+                    f"{fn.databook_name}::{fn.table_name}": fn.make_identifiers(
+                        param_id="return",
+                        mode="symbol"
+                    )[0]
+                }
+                for fn in func
+            ]
+
+            # res
+            return res
+        except Exception as e:
+            logger.error(f"Error in getting functions' identifiers: {e}")
+            return None
+
+    def get_data_structure(
+            self,
+            data: List[TableData]
+    ):
+        try:
+            # NOTE: init
+            res: Dict[str, Any] = {}
+
+            for dt in data:
+                # get info
+                db_name = dt.databook_name
+                tb_name = dt.table_name
+                prop_names = dt.property_names
+                symbols = dt.table_symbols
+
+                # set id
+                data_id = f"{db_name}::{tb_name}"
+
+                # build structure
+                res[data_id] = {
+                    "property_names": prop_names,
+                    "symbols": symbols
+                }
+
+            return res
+        except Exception as e:
+            logger.error(f"Error in getting data structure: {e}")
+            return None
+
+    def get_data_identifier(
+            self,
+            data: List[TableData]
+    ) -> Optional[List[Dict[str, List[str]]]]:
+        try:
+            res = [
+                {
+                    f"{dt.databook_name}::{dt.table_name}": dt.table_symbols
+                }
+                for dt in data
+            ]
+
+            # res
+            return res
+        except Exception as e:
+            logger.error(f"Error in getting data identifiers: {e}")
+            return None
+
+    def get_data_id_labels(
+            self,
+            data: List[TableData]
+    ) -> List[Dict[str, str]]:
+        '''
+        Get all available symbol labels
+
+        Parameters
+        ----------
+        data : List[TableData]
+            List of TableData objects to extract symbols from.
+
+        Returns
+        -------
+        List[Dict[str, str]]
+            A list of dictionaries containing symbol and their labels.
+        '''
+        try:
+            # SECTION: get TableData symbols
+            symbols = self.get_data_identifier(data)
+            if not symbols:
+                return []
+
+            # SECTION: find labels using SymbolController
+            res: List[Dict[str, str]] = []
+
+            for symbol_dict in symbols:
+                for symbol_list in symbol_dict.values():
+                    for symbol in symbol_list:
+                        label = self.symbol_controller.map_symbol_to_property_name(
+                            symbol)
+                        res.append({symbol: label})
+
+            return res
+        except Exception as e:
+            logger.error(f"Error listing properties: {e}")
+            return []