pyKES 0.1.6__tar.gz

pykes-0.1.6/PKG-INFO

@@ -0,0 +1,57 @@
+Metadata-Version: 2.4
+Name: pyKES
+Version: 0.1.6
+Summary: Python package for kinetic modelling of chemical reaction networks.
+Keywords: kinetics,photocatalysis,water-splitting,reaction-networks,ode
+Author: Jacob Schneidewind
+Author-email: Jacob Schneidewind <pyH2A.pypi@gmail.com>
+License-Expression: MIT
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Chemistry
+Requires-Dist: streamlit
+Requires-Dist: pandas
+Requires-Dist: numpy
+Requires-Dist: plotly
+Requires-Dist: matplotlib
+Requires-Dist: scipy
+Requires-Dist: h5py
+Requires-Dist: openpyxl
+Requires-Python: >=3.8
+Project-URL: Homepage, https://github.com/jschneidewind/pyKES
+Project-URL: Bug Tracker, https://github.com/jschneidewind/pyKES/issues
+Project-URL: Source, https://github.com/jschneidewind/pyKES
+Description-Content-Type: text/markdown
+
+# pyKES
+
+Working locally with pyKES:
+
+In other repo running
+pip install -e /Users/jacob/Documents/Water_Splitting/Projects/pyKES/pyKES
+
+Adding .vscode/setting.json file with
+
+{
+    "python.analysis.extraPaths": [
+        "/Users/jacob/Documents/Water_Splitting/Projects/pyKES/pyKES/src"
+    ],
+    "python.autoComplete.extraPaths": [
+        "/Users/jacob/Documents/Water_Splitting/Projects/pyKES/pyKES/src"
+    ]
+}
+
+
+## Contributing
+
+Contributions are welcome. Please open an issue or submit a pull request.
+
+## License
+
+This project is licensed under the MIT License. See [LICENSE](LICENSE).

pykes-0.1.6/README.md

@@ -0,0 +1,26 @@
+# pyKES
+
+Working locally with pyKES:
+
+In other repo running
+pip install -e /Users/jacob/Documents/Water_Splitting/Projects/pyKES/pyKES
+
+Adding .vscode/setting.json file with
+
+{
+    "python.analysis.extraPaths": [
+        "/Users/jacob/Documents/Water_Splitting/Projects/pyKES/pyKES/src"
+    ],
+    "python.autoComplete.extraPaths": [
+        "/Users/jacob/Documents/Water_Splitting/Projects/pyKES/pyKES/src"
+    ]
+}
+
+
+## Contributing
+
+Contributions are welcome. Please open an issue or submit a pull request.
+
+## License
+
+This project is licensed under the MIT License. See [LICENSE](LICENSE).

pykes-0.1.6/pyproject.toml

@@ -0,0 +1,51 @@
+[build-system]
+requires = ["uv_build>=0.11.13,<0.12"]
+build-backend = "uv_build"
+
+[project]
+name = "pyKES"
+version = "0.1.6"
+description = "Python package for kinetic modelling of chemical reaction networks."
+keywords = ["kinetics", "photocatalysis", "water-splitting", "reaction-networks", "ode"]
+authors = [
+    {name = "Jacob Schneidewind", email = "pyH2A.pypi@gmail.com"},
+]
+license = "MIT"
+readme = "README.md"
+requires-python = ">=3.8"
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Science/Research",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Scientific/Engineering :: Chemistry",
+]
+dependencies = [
+    "streamlit",
+    "pandas",
+    "numpy",
+    "plotly",
+    "matplotlib",
+    "scipy",
+    "h5py",
+    "openpyxl",  
+]
+
+[project.urls]
+"Homepage" = "https://github.com/jschneidewind/pyKES"
+"Bug Tracker" = "https://github.com/jschneidewind/pyKES/issues"
+"Source" = "https://github.com/jschneidewind/pyKES"
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+
+[tool.setuptools.packages.find]
+where = ["src"]
+include = ["pyKES*"]
+
+[tool.uv.build-backend]
+module-name = "pyKES"

pykes-0.1.6/src/pyKES/database/data_processing.py

@@ -0,0 +1,218 @@
+import os
+from concurrent.futures import ProcessPoolExecutor
+import multiprocessing
+from functools import partial
+import traceback
+from typing import Optional
+from pathlib import Path
+
+from pyKES.database.database_experiments import ExperimentalDataset, Experiment
+
+def generate_list_of_files(keywords, directory):
+
+    files = [
+        os.path.join(directory, file) 
+        for file in os.listdir(directory) 
+        if any(keyword in file for keyword in keywords)
+        and not file.startswith('~$')
+    ]
+
+    return files
+
+def read_in_single_experiment(file_name: str,
+                              database: ExperimentalDataset,
+                              metadata_retrival_function: callable, 
+                              raw_data_reading_function: callable,
+                              processing_function: callable,
+                              directory: Optional[Path] = None,
+                              legacy_mode = True):
+    """
+    Legacy mode is for use with file-based processing and use in multi-processing mode.
+
+    Non-legacy mode is for use with overview_df-based processing in single-threaded mode, 
+    where the file name is not necessarily the key to retrieve metadata and raw data.
+    In this case, the file name is used as an argument to the metadata retrieval function,
+    which then retrieves the necessary metadata and file paths for raw data reading and processing.
+
+
+    """
+    
+    try:
+        if legacy_mode:
+            metadata_dict = metadata_retrival_function(file_name, database.overview_df)
+            raw_data_dict = raw_data_reading_function(file_name, metadata_dict)
+            processed_data_dict = processing_function(raw_data_dict, metadata_dict)
+
+        else:
+            metadata_dict = metadata_retrival_function(file_name, database.overview_df)
+            raw_data_dict = raw_data_reading_function(directory, metadata_dict)
+            processed_data_dict = processing_function(raw_data_dict, metadata_dict)
+
+        experiment = Experiment(
+            experiment_name = metadata_dict['experiment_name'],
+            raw_data_file = file_name,
+            color = metadata_dict.get('color', 'black'),
+            group = metadata_dict.get('group', 'default'),
+            metadata = metadata_dict,
+            raw_data = raw_data_dict,
+            processed_data = processed_data_dict
+        )
+        
+        return {
+            'success': True,
+            'data': experiment
+        }
+
+    except Exception as e:
+        tb = traceback.format_exc()
+        print(f'{file_name} analysis failed, not added to dataset, error: {str(e)}')
+        print("Full traceback:")
+        print(tb)
+
+        return {
+            'success': False,
+            'file': file_name,
+            'error': f"{str(e)}\n\nFull traceback:\n{tb}"
+        }
+
+
+def read_in_experiments_single_threaded(database: ExperimentalDataset,
+                                        metadata_retrival_function: callable,
+                                        raw_data_reading_function: callable,
+                                        processing_function: callable,
+                                        overview_df_experiment_column: Optional[str] = 'Experiment',
+                                        directory: Optional[Path] = None):
+    """
+    
+    """
+
+    if "Processed" not in database.overview_df.columns:
+        database.overview_df["Processed"] = False
+
+    # Returning only the experiments which have not been processed 
+    # Do not contain "Processed" column or "Processed" is not True
+    # also returns experiments which are not in the database.experiments dict,
+
+    mask = (
+    database.overview_df["Processed"].ne('True')
+    | ~database.overview_df[overview_df_experiment_column].isin(database.experiments))
+    
+    experiments = database.overview_df.loc[mask, 
+                    overview_df_experiment_column].astype(str).tolist()
+    
+    results = []
+    
+    for experiment_name in experiments:
+
+        result = read_in_single_experiment(
+            file_name = experiment_name,
+            database = database,
+            metadata_retrival_function = metadata_retrival_function,
+            raw_data_reading_function = raw_data_reading_function,
+            processing_function = processing_function,
+            directory = directory,
+            legacy_mode = False
+        )
+
+        results.append(result)
+
+        if result['success']:
+            # Add experiment to database
+            database.add_experiment(result['data'])
+
+            # Setting "Processed" to True in dataframe
+            database.overview_df.loc[
+                database.overview_df[overview_df_experiment_column].eq(result['data'].experiment_name),
+                    "Processed",
+                ] = 'True'
+            
+        else:
+            print(f"Failed to process {result['file']}: {result['error']}")
+
+    return results
+
+
+def read_in_experiments_multiprocessing(database: ExperimentalDataset,
+                                        metadata_retrival_function: callable,
+                                        raw_data_reading_function: callable,
+                                        processing_function: callable,
+                                        keywords: Optional[list] = None, 
+                                        directory: Optional[str] = None,
+                                        overview_df_based_processing: Optional[bool] = False,
+                                        overview_df_experiment_column: Optional[str] = 'Experiment'): 
+    """
+    
+    """
+
+    if overview_df_based_processing:
+        files = database.overview_df[overview_df_experiment_column].tolist()
+    else:
+        files = generate_list_of_files(keywords, directory)
+
+    read_in_single_experiment_partial = partial(read_in_single_experiment, 
+                                          database = database,
+                                          metadata_retrival_function = metadata_retrival_function,
+                                          raw_data_reading_function = raw_data_reading_function,
+                                          processing_function = processing_function)
+
+    with ProcessPoolExecutor(max_workers=multiprocessing.cpu_count()) as executor:
+        results = list(executor.map(read_in_single_experiment_partial, files))
+
+    for result in results:
+        if result['success']:
+            database.add_experiment(result['data'])
+        else:
+            print(f"Failed to process {result['file']}: {result['error']}")
+
+    return results
+
+
+def testing():
+    
+    from tests.data.processing_functions_overview_df import (metadata_retrival_function, 
+                                                             raw_data_reading_function, 
+                                                             processing_function)
+    from tests.data.processing_parameters import PROCESSING_PARAMETERS, GROUP_MAPPING, PLOTTING_INSTRUCTIONS
+
+    import pandas as pd
+    import pprint as pp
+    
+    overview_df = pd.read_excel(
+        '/Users/jacob/Documents/Water_Splitting/Projects/pyKES/pyKES/src/tests/data/251204_O2_H2_Experiment_Overview.xlsx',
+        sheet_name='Sheet1',
+        dtype={'active': str,
+               'D2O': str,
+               'Processed': str}  # Force 'active' and 'D2O' columns to be read as strings
+    )
+
+    dataset = ExperimentalDataset(
+                    overview_df = overview_df,
+                    group_mapping = GROUP_MAPPING,
+                    plotting_instruction = PLOTTING_INSTRUCTIONS,
+                    processing_parameters = PROCESSING_PARAMETERS
+                    )
+    
+    read_in_experiments_single_threaded(
+        database = dataset,
+        metadata_retrival_function = metadata_retrival_function,
+        raw_data_reading_function = raw_data_reading_function,
+        processing_function = processing_function,
+        overview_df_experiment_column = 'Experiment',
+        directory = Path('/Users/jacob/Documents/Water_Splitting/Projects/pyKES/pyKES/src/tests/data/data_files')
+    )
+
+    pp.pprint(dataset.experiments['NB-316'])
+
+
+
+
+
+
+
+
+
+
+
+
+if __name__ == '__main__':
+    testing()