first commit

.gitattributes

@@ -0,0 +1,3 @@
+*.pdf filter=lfs diff=lfs merge=lfs -text
+marimo/docs/*.pdf filter=lfs diff=lfs merge=lfs -text
+marimo/docs/*.docx filter=lfs diff=lfs merge=lfs -text

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Paolo Raiteri
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,2 @@
+# pycek
+python package for CHEM2000

build/lib/pycek_public/__init__.py

@@ -0,0 +1,10 @@
+from .cek_labs import *
+
+from .generate_random_filenames import *
+from .logger import *
+
+from .statistics_lab import *
+from .bomb_calorimetry import *
+from .crystal_violet import *
+from .surface_adsorption import *
+

build/lib/pycek_public/bomb_calorimetry.py

@@ -0,0 +1,113 @@
+import pycek_public as cek
+import numpy as np
+import pprint as pp
+
+class bomb_calorimetry(cek.cek_labs):
+    def setup_lab(self):
+        """
+        Define base information for the lab
+        """
+        self.add_metadata( 
+            laboratory = 'Bomb Calorimetry',
+            columns = ["Time (s)","Temperature (K)"]
+            )
+
+        self.available_samples = ['benzoic', 'sucrose', 'naphthalene']
+
+        self.ignition_time = 20
+        self.relaxation_time = 3
+        self.number_of_values = 100
+        self.noise_level = 0.1
+
+        self.slope_before = np.random.uniform(0., self.noise_level) / 3
+        self.slope_after = np.random.uniform(0., self.noise_level) / 3
+        
+        self.RT = self.R * self.temperature
+        
+        # calorimeter constant (J/K)
+        self.calorimeter_constant = {'value':10135,'std_error':0.0}
+        self.sample_parameters["co2"] = {
+            "mM" : 44.01,
+            "dH" : -393.51e3, # co2 enthapy of formation (J/mol/K)
+        }
+        self.sample_parameters["h2o"] = {
+            "mM" : 18.015,
+            "dH" : -285.83e3,# h2o enthapy of formation (J/mol/K)
+        }    
+            
+        self.sample_parameters["benzoic"] = {
+            "mM" : 122.123,
+            "n1" : 7,
+            "n2" : 3,
+            "dn" : 7-15/2,
+            "dHf" : {'value':-384.8e3,'std_error':0.5e3},
+            "dHc" : {'value':-3227.26e3,'std_error':0.2e3},
+        }
+        self.sample_parameters["sucrose"] = {
+            "mM" : 342.3,
+            "n1" : 12,
+            "n2" : 11,
+            "dn" : 0,
+            "dHf" : {'value':-2221.2e3,'std_error':0.2e3},
+            "dHc" : {'value':-5643.4e3,'std_error':1.8e3},
+        }
+        self.sample_parameters["naphthalene"] = {
+            "mM" : 128.17,
+            "n1" : 10,
+            "n2" : 4,
+            "dn" : 10 - 12,
+            "dHf" : {'value':77e3,'std_error':10.0e3},
+            "dHc" : {'value':-5160e3,'std_error':20.0e3},
+        }
+
+    def create_data(self):
+        """
+        Generate the data
+        """
+        if self.sample is None:
+            raise Exception("Sample not defined")
+
+        prm = self.sample_parameters[ self.sample ]
+
+        self.set_parameters( 
+            sample = self.sample,
+            number_of_values = self.number_of_values,
+            )
+
+        self.mass = np.random.normal(1000, 100)
+        self.add_metadata(**{
+            'Tablet mass (mg)': self.mass,
+            "Ignition time (s)" : self.ignition_time,
+            "Sample" : self.sample, 
+            })
+
+        moles = self.mass / 1000 / prm["mM"]
+
+        # combustion enthalpy
+        # nH{co2} + mH{h2o} - H = DcH
+        DcH = prm["n1"] * self.sample_parameters["co2"]["dH"] + \
+              prm["n2"] * self.sample_parameters["h2o"]["dH"] - prm["dHf"]["value"]
+
+        dH = DcH * moles
+        dnrt = moles * self.RT * prm["dn"]
+        dU = dH - dnrt
+        
+        deltaT = -dU / self.calorimeter_constant['value']
+
+        x = np.linspace(0, self.number_of_values, self.number_of_values)
+        y = np.random.normal(0, self.noise_level, self.number_of_values)
+
+        dd = 0.
+        T = self.temperature
+        for i in range(self.number_of_values):
+            if i < self.ignition_time:
+                T += self.slope_before 
+            else:   
+                T += self.slope_after
+                dd = deltaT * (1 - np.exp( - (i - self.ignition_time) / self.relaxation_time) )
+            y[i] += T + dd 
+
+        self.data = np.column_stack((x,y))
+
+        return
+

build/lib/pycek_public/cek_labs.py

@@ -0,0 +1,388 @@
+import pycek_public as cek
+import numpy as np
+from collections import OrderedDict
+
+from abc import ABC, abstractmethod
+class cek_labs(ABC):
+    def __init__(self, **kwargs):        
+        self.token = None
+        self.student_ID = 123456789
+
+        self.noise_level = 1
+        self.precision = 1
+        
+        self.available_samples = []
+        self.sample_parameters = {}
+        self.sample = None
+
+        self.R = 8.314
+        self.NA = 6.022e23
+        self.temperature = 298
+
+        self.number_of_values = 100
+        self.output_file = None
+        self.filename_gen = cek.TempFilenameGenerator()
+
+        self.metadata = OrderedDict({
+            'student_ID' : self.student_ID,
+            'number_of_values' : self.number_of_values,
+            'output_file' : self.output_file,
+        })
+        
+        self.logger_level = "ERROR"
+
+        # Define some lab specific parameters
+        # Can overwrite the defaults
+        for k,w in kwargs.items():
+            setattr(self, k, w)
+        np.random.seed(self.student_ID)
+
+        self.logger = cek.setup_logger(level=self.logger_level)
+        # self.logger.debug("This is a debug message")
+        # self.logger.verbose("This is a verbose message")  # New verbose level
+        # self.logger.info("This is an info message")
+        # self.logger.result("This is an result message")
+        # self.logger.warning("This is a warning message")
+        # self.logger.error("This is an error message")
+        # self.logger.critical("This is a critical message")
+        # quit()
+
+        # Lab specific parameters
+        self.setup_lab()
+
+    def __str__(self):
+        return f'CHEM2000 Lab: {self.__class__.__name__}'
+
+    def set_student_ID(self,student_ID):
+        if isinstance(student_ID,int):
+            self.student_ID = student_ID
+        elif isinstance(student_ID,str):
+            if student_ID.isdigit():
+                self.student_ID = int(student_ID)
+            else:
+                raise ValueError("student_ID must be an integer")
+        else:
+            raise ValueError("student_ID must be an integer")
+        np.random.seed(self.student_ID)
+        self.update_metadata_from_attr()
+        self.logger.debug(f"Initial seed = {np.random.get_state()[1][0]}")
+
+    def set_token(self, token):
+        self.token = token
+        #print(f"Check: {self._check_token()}")
+
+    def _check_token(self):
+        if self.token != 23745419:
+            return True
+        return False
+
+    def add_metadata(self, **kwargs):
+        for key, value in kwargs.items():
+            self.metadata[key] = value
+        return
+    
+    def update_metadata_from_attr(self):
+        for k in self.metadata:
+            try:
+                self.metadata[k] = getattr(self, k)
+            except:
+                pass
+        return
+    
+    def set_parameters(self, **kwargs):
+        """
+        Set parameters for the lab
+        """
+        for k,w in kwargs.items():
+            if k == "student_ID":
+                self.set_student_ID(w)
+            else:
+                setattr(self, k, w)
+        self.update_metadata_from_attr()
+        return
+
+    def write_metadata(self,f=None):
+        """
+        Write metadata to the data file
+        """
+        if f is None:
+            def dump(s):
+                self.logger.info(s)
+        else:
+            def dump(s):
+                with open(f, 'a') as file:
+                    file.write(f"# {s}\n")
+
+        for key, value in self.metadata.items():
+            string = f"{key}"
+            string = string.replace("_"," ")
+            string = string[0].upper() + string[1:] + f" = {value}"
+            dump(string)
+
+    def read_metadata(self,f):
+        """
+        Read metadata from the data file
+        
+        Return: metadata (dict)
+        """
+        metadata = OrderedDict({})
+
+        hash_lines = []
+        with open(f, 'r') as file:
+            for line in file:
+                if line.strip().startswith('#'):
+                    hash_lines.append(line.replace('#','').strip())
+        
+        for l in hash_lines:
+            if ":" in l:
+                key, value = l.split(':')
+            elif "=" in l:
+                key, value = l.split('=')
+            else:
+                raise Exception("Unknown separator")
+            key = key.replace("#","").strip()
+            metadata[key] = value.strip()
+            
+        return metadata
+
+    def write_data_to_file(self, **kwargs):
+        """
+        """
+        if self.output_file is None:
+            filename = self.filename_gen.random
+        else:
+            filename = self.output_file
+        self.add_metadata(output_file=filename)
+
+        with open(filename, 'w') as f:
+            # Write the column names
+            cols = None
+            if "columns" in kwargs:
+                cols = kwargs["columns"]
+            elif "columns" in self.metadata:
+                cols = self.metadata["columns" ]
+            if cols is not None:
+                f.write(",".join(cols) + "\n")
+
+            # Convert NumPy array to list if needed
+            # if isinstance(self.data, np.ndarray):
+            #     self.data = self.data.tolist()
+
+            # Write data
+            for row in self.data:
+                # Handle multiple columns
+                if isinstance(row, (list, tuple, np.ndarray)):
+                    line = ",".join(map(str, row))
+                # Handle single-column case
+                else:
+                    line = str(row)
+                f.write(line + "\n")
+
+        # Write the kwargs as metadata
+        self.write_metadata(filename)
+
+        return filename
+
+    def read_data_file(self,filename=None):
+        if filename is None:
+            raise ValueError("Filename is missing")
+
+        # Read file and separate comments from data
+        comments = []
+        data_lines = []
+
+        with open(filename, "r") as f:
+            for line in f:
+                if line.startswith("#"):
+                    comments.append(line.strip())  # Store comment lines
+                else:
+                    data_lines.append(line.strip())  # Store data lines
+
+        # Extract header and data
+        header = data_lines[0]  # First non-comment line is the header
+        data_lines = "\n".join(data_lines[0:])  # Join remaining lines as CSV data
+
+        # Convert CSV data to NumPy array
+        from io import StringIO
+        from numpy.lib.recfunctions import structured_to_unstructured
+
+        data = np.genfromtxt(
+            StringIO(data_lines), delimiter=',', 
+            comments='#', names=True, 
+            skip_header=0, dtype=None)   
+        
+        data_array = structured_to_unstructured(data)
+
+        metadata = None
+        if len(comments) > 0:
+            metadata = OrderedDict({})
+            for l in comments:
+                if ":" in l:
+                    key, value = l.split(':')
+                elif "=" in l:
+                    key, value = l.split('=')
+                else:
+                    raise Exception("Unknown separator")
+                key = key.replace("#","").strip()
+                metadata[key.strip()] = value.strip()
+
+        # Output results
+        # print("Comments:")
+        # print("\n".join(comments))
+        # print("\nExtracted Data:")
+        # print(data_array)
+        return data_array, header, metadata
+
+    def process_file(self, filename=None):
+        self.read_data(filename)
+        result = self.process_data()
+        return result
+    
+    def _valid_ID(self,ID):
+        if ID in ["23745411"]:
+            return True
+        return False
+        
+    def _round_values(self, values, precision=None):
+        if precision is None:
+            precision = self.precision
+        rounded_values = [round(v, precision) for v in values]
+        values = np.array(rounded_values, dtype=float)
+        return values
+    
+    def _generate_uniform_random(self, lower, upper, n):
+        return self._round_values(np.random.uniform(lower, upper, n))
+
+    def _generate_normal_random(self,n,prm):
+        list_of_1d_arrays = []
+        for p in prm:
+            values = np.random.normal(p[0], p[1], size=n)
+            list_of_1d_arrays.append(self._round_values(values))
+
+        if len(prm) == 1:
+            return np.array(self._round_values(values))
+        else:
+            return np.column_stack( [*list_of_1d_arrays] )
+
+    def _generate_noise(self,n,noise_level=None,ntype="normal"):
+        if noise_level == None:
+            raise ValueError("Missing noise level")
+        if noise_level <= 0:
+            return np.zeros(n)
+        if ntype == "normal":
+            return np.random.normal(0, noise_level, size=n)
+
+    def _generate_data_from_function(self, func, params, nvalues, xrange):
+        x = np.sort(self._generate_uniform_random(nvalues,*xrange))
+        y = func(x, *params) + self._generate_noise(nvalues)
+        y = self._round_values(y)
+        return np.column_stack((x,y))
+
+    import numpy as np
+    from typing import Callable, Dict, Optional, Union, Tuple
+
+    def generate_data_from_function(
+        self,
+        function: Callable,
+        params: Dict,
+        nvalues: int,
+        xrange: Optional[Tuple[float, float]] = None,
+        xspacing: str = 'random',
+        noise_level: Optional[float] = None,
+        background: Optional[float] = None,
+        weights: Optional[bool] = None,
+        positive: bool = False
+    ) -> np.ndarray:
+        """
+        Generate synthetic data points from a given function with optional noise and background.
+
+        Parameters
+        ----------
+        function : callable
+            The model function to generate data from. Should accept x values and **kwargs.
+        params : dict
+            Parameters to pass to the function as keyword arguments.
+        nvalues : int
+            Number of data points to generate.
+        xrange : tuple of float, optional
+            Range of x values (min, max). Required if generating data points.
+        xspacing : str, default='random'
+            Method to space x values. Options:
+            - 'linear': Evenly spaced points
+            - 'random': Uniformly distributed random points
+        noise_level : float, optional
+            Standard deviation of Gaussian noise to add to y values.
+        background : float, optional
+            Constant background level to add to all y values.
+        weights : bool, optional
+            If True, include weights in output (NOT IMPLEMENTED).
+        positive : bool, default=False
+            If True, take absolute value of final y values.
+
+        Returns
+        -------
+        np.ndarray
+            2D array with shape (nvalues, 2) containing (x, y) pairs.
+
+        Raises
+        ------
+        ValueError
+            If xrange is None or invalid xspacing type is provided.
+        """
+        # Validate inputs
+        if xrange is None:
+            raise ValueError("xrange must be provided as (min, max) tuple")
+        
+        if not isinstance(nvalues, int) or nvalues <= 0:
+            raise ValueError("nvalues must be a positive integer")
+
+        # Generate x values
+        if xspacing == "linear":
+            x = np.linspace(*xrange, nvalues)
+        elif xspacing == "random":
+            x = np.sort(self._generate_uniform_random(*xrange, nvalues))
+        else:
+            raise ValueError(f"xspacing must be 'linear' or 'random', got '{xspacing}'")
+
+        # Generate base y values from function
+        y = function(x, **params)
+
+        # Add optional modifications
+        if background is not None:
+            y += background
+        
+        if noise_level is not None:
+            y += self._generate_noise(nvalues,noise_level)
+        
+        if positive:
+            y = np.abs(y)
+
+        # Note: weights parameter is currently unused
+        if weights is not None:
+            # TODO: Implement weights handling
+            pass
+
+        y = self._round_values(y)
+
+        return np.column_stack((x, y))
+
+    def create_data_file(self):
+        data = self.create_data()
+        self.write_data_to_file(
+            self.metadata['output_file'], 
+            data, **self.metadata )
+        return self.metadata['output_file']
+    
+    def get_data(self):
+        return self.data
+    def get_metadata(self):
+        return self.metadata
+
+    @abstractmethod
+    def setup_lab(self,**kwargs):
+        pass
+
+    @abstractmethod
+    def create_data(self):
+        pass
+

build/lib/pycek_public/crystal_violet.py

@@ -0,0 +1,75 @@
+import pycek_public as cek
+import numpy as np
+
+class crystal_violet(cek.cek_labs):
+    def setup_lab(self):
+        """
+        Define base information for the lab.
+        They can be overwrite by the user using the kwargs in the constructor or
+        by calling the set_parameters method.
+        """
+        self.add_metadata( 
+            laboratory = 'Crystal Violet Lab',
+            columns = ["Time (s)","Absorbance"]
+            )
+
+        self.expt_time = 1000
+        self.number_of_values = 501
+        self.noise_level = 0.1
+        self.precision = 4
+        
+        self.activation_energy = 63e3 # J/mol
+        self.prefactor = 5.9e9 # 1/M/s
+        
+        # Order wrt CV and OH
+        self.alpha = 1.0
+        self.beta = 0.75
+        self.conc_to_abs = 160e3 # Absorbivity of CV at 590 nm (L/mol/cm)
+        self.stock_solutions = {"cv" : 2.5e-5, "oh" : 0.5} # mol/L
+        
+        self.volumes = {"cv" : 10, "oh" : 10, "h2o" : 10.0} # mL
+
+    def create_data(self):
+        """
+        Generate the data
+        """
+        self.set_parameters( 
+            sample = self.sample,
+            number_of_values = self.number_of_values,
+            )
+
+        self.add_metadata(**{
+            "Temperature (C)"   : self.temperature-273.15,
+            "Volume of CV (mL)" : self.volumes['cv'],
+            "Volume of OH (mL)" : self.volumes['oh'],
+            "Volume of H2O (mL)": self.volumes['h2o'],
+        })
+
+        vtot = np.sum( [ x + np.random.normal(0,self.noise_level,1) for x in self.volumes.values() ] )
+        initial_concentration_cv = \
+            self.stock_solutions["cv"] * self.volumes["cv"] / vtot
+
+        concetration_oh = \
+            self.stock_solutions["oh"] * self.volumes["oh"] / vtot
+
+        rate_constant = self.prefactor*np.exp(-self.activation_energy/(self.R*(self.temperature)))
+        pseudo_rate_constant = rate_constant * np.power(concetration_oh,self.beta)
+
+        params = {
+            "A" : initial_concentration_cv* self.conc_to_abs,
+            "k" : pseudo_rate_constant    
+        }
+
+        self.data = self.generate_data_from_function(
+                lambda x,A,k: A * np.exp(-k * x) , 
+                params, 
+                self.number_of_values,
+                xrange = [0, self.expt_time], 
+                xspacing = 'linear',
+                noise_level = self.noise_level,
+                positive = True,
+                background = 0.1
+                )
+        
+        return 
+    

build/lib/pycek_public/generate_random_filenames.py

@@ -0,0 +1,166 @@
+import os
+from glob import glob
+import secrets
+import string
+
+class TempFilenameGenerator:
+    """
+    Generates temporary filenames with .pdb extension and increasing indices.
+    Supports both sequential (tmp.{index}.pdb) and random (tmp.{random}.pdb) formats.
+    """
+    def __init__(self, directory=".", root="data", ext="csv", random_length=12):
+        """
+        Initialize the generator with a target directory.
+        
+        Args:
+            directory (str): Directory for the filenames (default: current directory)
+            root (str): Root name for the temporary files (default: tmp)
+            ext (str): File extension (default: pdb)
+            random_length (int): Length of random string in random filenames (default: 12)
+
+        Example:
+            generator = TempFilenameGenerator()
+
+            # Get sequential filename (e.g., "tmp.0.pdb")
+            sequential_file = generator.next
+
+            # Get random filename (e.g., "tmp.j4k3h2l5m9n8.pdb")
+            random_file = generator.random
+        """
+        self.directory = directory
+        self.root = root
+        self.ext = ext
+        self.random_length = random_length
+        self._current_index = self._find_max_index()
+        self._current_filename = None
+
+    def _find_max_index(self):
+        """Find the highest existing index in the directory."""
+        pattern = os.path.join(self.directory, f"{self.root}.*.{self.ext}")
+        existing_files = glob(pattern)
+        
+        if not existing_files:
+            return -1
+            
+        indices = []
+        for filename in existing_files:
+            try:
+                # Extract index from tmp.{index}.pdb
+                index = int(os.path.basename(filename).split('.')[-2])
+                indices.append(index)
+            except (ValueError, IndexError):
+                continue
+                
+        return max(indices) if indices else -1
+
+    def _generate_random_string(self):
+        """Generate a cryptographically secure random string."""
+        alphabet = string.ascii_letters + string.digits
+        return ''.join(secrets.choice(alphabet) for _ in range(self.random_length))
+
+    def delete_files(self):
+        """Delete all temporary files in the directory."""
+        pattern = os.path.join(self.directory, f"{self.root}.*.{self.ext}")
+        for filename in glob(pattern):
+            os.remove(filename)
+        self._current_index = -1
+            
+    def copy_last(self, dest):
+        """Copy the last generated file to a destination."""
+        if self._current_filename is None:
+            raise ValueError("No files have been generated yet")
+        os.system(f"cp {self._current_filename} {dest}")
+        
+    @property
+    def next(self):
+        """Generate the next filename in sequence."""
+        self._current_index += 1
+        filename = f"{self.root}.{self._current_index}.{self.ext}"
+        self._current_filename = os.path.join(self.directory, filename)
+        return self._current_filename
+
+    @property
+    def random(self):
+        """Generate a random filename."""
+        random_string = self._generate_random_string()
+        filename = f"{self.root}.{random_string}.{self.ext}"
+        self._current_filename = os.path.join(self.directory, filename)
+        return self._current_filename
+
+    @property
+    def current_index(self):
+        """Get the current index value."""
+        return self._current_index
+
+    @property
+    def current(self):
+        """Get the current filename."""
+        return self._current_filename
+    
+# import random
+# import string
+# import os
+# from typing import Optional
+
+# def generate_random_filename(
+#     extension: Optional[str] = 'csv',
+#     length: Optional[int] = 10,
+#     prefix: Optional[str] = 'data_',
+#     directory: Optional[str] = '',
+#     existing_check: Optional[bool] = True
+# ) -> str:
+#     """
+#     Generate a random filename with optional parameters.
+    
+#     Args:
+#         extension (str): File extension to append (e.g., '.txt', '.pdf')
+#         length (int): Length of the random string (default: 10)
+#         prefix (str): Prefix to add before the random string
+#         directory (str): Directory path where the file will be created
+#         existing_check (bool): Whether to check if filename already exists
+    
+#     Returns:
+#         str: Generated filename
+        
+#     Raises:
+#         ValueError: If length is less than 1
+#         ValueError: If unable to generate unique filename after 100 attempts
+#     """
+#     if length < 1:
+#         raise ValueError("Length must be at least 1")
+        
+#     # Clean up the extension
+#     if extension and not extension.startswith('.'):
+#         extension = '.' + extension
+        
+#     # Clean up the directory path
+#     if directory:
+#         directory = os.path.abspath(directory)
+#         if not os.path.exists(directory):
+#             os.makedirs(directory)
+            
+#     attempts = 0
+#     max_attempts = 100
+    
+#     while True:
+#         # Generate random string using ASCII letters and digits
+#         random_string = ''.join(
+#             random.choices(string.ascii_letters + string.digits, k=length)
+#         )
+        
+#         # Combine all parts of the filename
+#         filename = f"{prefix}{random_string}{extension}"
+        
+#         # Add directory path if specified
+#         if directory:
+#             filename = os.path.join(directory, filename)
+            
+#         # Check if file exists (if requested)
+#         if not existing_check or not os.path.exists(filename):
+#             return filename
+            
+#         attempts += 1
+#         if attempts >= max_attempts:
+#             raise ValueError(
+#                 f"Unable to generate unique filename after {max_attempts} attempts"
+#             )

build/lib/pycek_public/logger.py

@@ -0,0 +1,112 @@
+import sys
+import logging
+import colorama
+from colorama import Fore, Style
+
+# Initialize colorama to work on Windows too
+colorama.init()
+
+# Define custom VERBOSE level (between DEBUG-10 and INFO-20)
+VERBOSE = 15
+logging.addLevelName(VERBOSE, 'VERBOSE')
+RESULT = 25
+logging.addLevelName(RESULT, 'RESULT')
+
+class ColoredFormatter(logging.Formatter):
+    """Custom formatter that adds colors to log messages based on level with fixed width"""
+    COLORS = {
+        'DEBUG': Fore.CYAN + Style.BRIGHT,
+        'VERBOSE': Fore.BLUE + Style.BRIGHT,
+        'INFO': Fore.GREEN + Style.BRIGHT,
+        'RESULT' : Fore.RESET + Style.BRIGHT,
+        'WARNING': Fore.YELLOW + Style.BRIGHT,
+        'ERROR': Fore.RED + Style.BRIGHT,
+        'CRITICAL': Fore.MAGENTA + Style.BRIGHT
+    }
+    LEVEL_NAME_WIDTH = 8
+
+    def format(self, record):
+        # Save original levelname and message
+        orig_levelname = record.levelname
+        orig_msg = record.msg
+
+        # Determine the color for the level
+        color_code = self.COLORS.get(orig_levelname, '')
+
+        # Calculate padding for levelname
+        padding = ' ' * (self.LEVEL_NAME_WIDTH - len(orig_levelname))
+
+        # Apply color to levelname with padding
+        record.levelname = f"{color_code}{orig_levelname}{padding}{Style.RESET_ALL}"
+
+        # Apply color to the message as well
+        record.msg = f"{color_code}{orig_msg}{Style.RESET_ALL}"
+
+        # Format the message
+        result = super().format(record)
+
+        # Restore original values
+        record.levelname = orig_levelname
+        record.msg = orig_msg
+        return result
+    
+class ColoredLogger(logging.Logger):
+    """Custom logger class with verbose method"""
+    
+    def verbose(self, msg, *args, **kwargs):
+        """Log at custom VERBOSE level"""
+        if self.isEnabledFor(VERBOSE):
+            self._log(VERBOSE, msg, args, **kwargs)
+            
+    def result(self, msg, *args, **kwargs):
+        """Log at custom RESULT level"""
+        if self.isEnabledFor(RESULT):
+            self._log(RESULT, msg, args, **kwargs)
+            
+    # logging.Logger.result = custom_logging
+
+def setup_logger(name='colored_logger', level="INFO"):
+    """Set up and return a colored logger instance"""
+    
+    # Register our custom logger class
+    logging.setLoggerClass(ColoredLogger)
+    
+    # Create logger
+    logger = logging.getLogger(name)
+    
+    # Set logger level
+    try:
+        logger.setLevel(getattr(logging, level.upper()))
+    except AttributeError:
+        logger.setLevel(logging.INFO)  # Default to INFO if invalid level
+    
+    # Create console handler
+    console_handler = logging.StreamHandler(sys.stdout)
+    console_handler.setLevel(level)
+    
+    # Create formatter
+    formatter = ColoredFormatter(
+        # fmt='%(asctime)s - %(levelname)s - %(message)s',
+        # datefmt='%Y-%m-%d %H:%M:%S'
+        fmt='%(levelname)8s - %(message)s'
+    )
+    
+    # Add formatter to handler
+    console_handler.setFormatter(formatter)
+    
+    # Add handler to logger
+    logger.addHandler(console_handler)
+    
+    return logger
+
+# Example usage
+if __name__ == '__main__':
+    logger = setup_logger()
+    
+    # Test all log levels including new VERBOSE level
+    logger.debug("This is a debug message")
+    logger.verbose("This is a verbose message")  # New verbose level
+    logger.info("This is an info message")
+    logger.warning("This is a warning message")
+    logger.error("This is an error message")
+    logger.critical("This is a critical message")

build/lib/pycek_public/statistics_lab.py

@@ -0,0 +1,125 @@
+import pycek_public as cek
+import numpy as np
+
+class stats_lab(cek.cek_labs):
+    def setup_lab(self):
+        """
+        Define base information for the lab
+        """
+        self.add_metadata( 
+                          laboratory = 'Basic Statistics Lab',
+                          columns = ["X","Y"]
+                          )
+
+        self.available_samples = [
+            'Averages',
+            'Propagation of uncertainty',
+            'Comparison of averages',
+            'Linear fit',
+            'Non linear fit',
+            'Detection of outliers',
+        ]
+    
+        self.sample_parameters['Averages'] = {
+            "gen_values" : [
+                (1.0, 0.1),
+                (12., 2.0)
+            ],
+            'exp_values' : (1.0,9.0),
+            }
+        
+        self.sample_parameters['Propagation of uncertainty'] = {
+            "gen_values" : [
+                (15.0, 1.0),
+                (133., 2.0)
+            ],
+            }
+
+        self.sample_parameters['Comparison of averages'] = {
+            "gen_values" : [
+                (15.0, 1.0),
+                (13.2, 2.0)
+            ],
+            }
+
+        self.sample_parameters['Linear fit'] = {
+            "function" : lambda x,m,q: m*x + q, 
+            "gen_values" : {'m':12.3 , 'q':1.0},
+            "xrange" : [0.0 , 10.0]
+            }
+
+        self.sample_parameters['Non linear fit'] = {
+            "nval" : 10,
+            "function" : lambda x,E0,K0,Kp,V0:  E0 + K0 * x / Kp * ( (V0/x)**Kp / (Kp-1)+1) - K0*V0/(Kp-1), 
+            "gen_values" : {"E0":-634.2, "K0":12.43, "Kp":4.28, "V0":99.11},
+            "xrange" : [50 , 140]
+        }
+        
+        self.sample_parameters['Detection of outliers'] = {
+            "function" : lambda x,m,q: m*x + q, 
+            "gen_values" : {'m':2.3 , 'q':0.1},
+            "xrange" : [10.0 , 20.0],
+            "shift" : 2,
+            }
+        
+    def create_data(self):
+        """
+        Generate the data
+        """
+        if self.sample is None:
+            raise Exception("Sample not defined")
+
+        prm = self.sample_parameters[ self.sample ]
+        
+        if self.user_specified_file is None:
+            output_file = self.filename_gen.random
+        else:
+            output_file = self.output_file
+            
+        self.set_parameters( 
+            number_of_values = self.number_of_values,
+            output_file = output_file,
+            )
+        
+        if "noise" in prm:
+            self.set_parameters( noise_level = prm["noise"] )
+
+        self.add_metadata(
+            number_of_values = self.number_of_values,
+            sample = self.sample,
+        )
+        
+        if self.sample in ["Averages", 'Propagation of uncertainty', 'Comparison of averages']:
+            data = self._generate_normal_random(self.number_of_values, prm['gen_values'])
+
+        elif self.sample in ["Linear fit"]:
+            data = self.generate_data_from_function(
+                prm["function"], 
+                prm['gen_values'], 
+                self.number_of_values,
+                prm['xrange'], 
+                noise_level = self.noise_level,
+                )
+
+        elif self.sample in ["Non linear fit"]:
+            data = self.generate_data_from_function(
+                prm["function"], 
+                prm['gen_values'], 
+                self.number_of_values,
+                prm['xrange'], 
+                noise_level = self.noise_level,
+                )
+        
+        elif self.sample in ["Detection of outliers"]:
+            data = self.generate_data_from_function(
+                prm["function"], 
+                prm['gen_values'], 
+                self.number_of_values,
+                prm['xrange'], 
+                noise_level = self.noise_level,
+                )
+            i = np.random.randint(self.number_of_values)
+            data[i,1] += prm['shift']
+
+        return data            
+

build/lib/pycek_public/surface_adsorption.py

@@ -0,0 +1,89 @@
+import pycek_public as cek
+import numpy as np
+
+class surface_adsorption(cek.cek_labs):
+    def setup_lab(self):
+        """
+        Define base information for the lab.
+        They can be overwrite by the user using the kwargs in the constructor or
+        by calling the set_parameters method.
+        """
+        self.add_metadata( 
+            laboratory = 'Surface Adsorption Lab',
+            columns = ["Dye added (mg)", "Dye in solution (mol/L)"]
+            )
+        
+        self.volume = 1 # L
+        self.minDye = 500 # mg
+        self.maxDye = 10000 # mg
+        
+        self.sample_parameters = {
+            "dH"       : -19.51e3, # J/mol
+            "dS"       : -10, # J/mol/K
+            "Q"        : 0.0001, # monolayer coverage (mol/m^2)
+            "molarMass": 584.910641, # g/mol
+            }
+
+        self.number_of_values = 100 
+        self.noise_level = 1e-6
+        self.precision = 10
+
+    def create_data(self):
+        """
+        Generate the data
+        """
+        if self.user_specified_file is None:
+            output_file = self.filename_gen.random
+        else:
+            output_file = self.output_file
+
+        self.set_parameters( 
+            sample = self.sample,
+            number_of_values = self.number_of_values,
+            output_file = output_file,
+            )
+
+        self.add_metadata(**{
+            "Temperature (K)"    : self.temperature,
+            "Volume (L)"         : self.volume,
+            "Molar mass (g/mol)" : self.sample_parameters["molarMass"],
+            "MinDye (mg)"        : self.minDye,
+            "MaxDye (mg)"        : self.maxDye,
+            'Number of values'   : self.number_of_values,
+        })
+
+        # Langmuir isotherm equilibrium constant
+        # Convert to kJ/mol
+        lnK = (-self.sample_parameters["dH"] / (self.temperature) + self.sample_parameters["dS"]) / self.R
+        K = np.exp(lnK) # in L/mol
+
+        conversion_factor = 1000 * self.sample_parameters["molarMass"] * self.volume
+        conc_range = np.array([self.minDye, self.maxDye]) / conversion_factor
+
+        data_array = self.generate_data_from_function(
+                lambda x,K,Q: ((x*K - K*Q - 1) + np.sqrt((x*K - K*Q - 1)**2 + 4*x*K) ) / (2*K) , 
+                {"K":K , "Q":self.sample_parameters["Q"]}, 
+                self.number_of_values,
+                xrange = conc_range, 
+                xspacing = 'linear',
+                noise_level = self.noise_level,
+                positive = True,
+                )
+            
+        data_array[:,0] *= conversion_factor
+        # grams of dye added
+        # x = np.linspace(self.minDye, self.maxDye, self.number_of_values) / 1000
+        # moles = x / self.params["molarMass"] # g
+        # initial_concentration = moles / self.volume # mol/L
+        # y = self.measure(K, self.params["Q"], initial_concentration)
+        
+        # # Because noise is added to the concentration in solution, but
+        # # the concentration on the surface is required in post-processing, which 
+        # # is very small, we divide by 1000
+
+        # y = cek.add_noise(y, self.uncertainty/1000)
+
+        # data_array = np.column_stack((x, y))
+
+        return data_array
+

deployment/Dockerfile

@@ -0,0 +1,22 @@
+FROM python:3.12
+COPY --from=ghcr.io/astral-sh/uv:0.4.20 /uv /bin/uv
+
+RUN useradd -m -u 1000 user
+ENV PATH="/home/user/.local/bin:$PATH"
+ENV UV_SYSTEM_PYTHON=1
+
+WORKDIR /app
+
+COPY --chown=user ./deployment/requirements.txt requirements.txt
+RUN uv pip install -r requirements.txt
+
+# Copy and install the local repo, then remove it
+COPY --chown=user ./ /pycek_public
+RUN uv pip install /pycek_public && rm -rf /pycek 
+
+COPY --chown=user ./marimo /app
+RUN chown -R user:user /app
+
+USER user
+
+CMD ["python", "app.py"]

deployment/README.md

@@ -0,0 +1,9 @@
+**Will need to be run in this directory**
+
+Run `./build.sh` which will build the docker file as `cek-marimo`
+
+The container may then be run as e.g.
+
+```
+docker run -p 8000:8000 cek-marimo
+```

deployment/build.sh

@@ -0,0 +1,3 @@
+#!/usr/bin/env bash
+
+docker build -t cek-marimo -f Dockerfile ..

deployment/requirements.txt

@@ -0,0 +1,3 @@
+fastapi
+colorama
+marimo

marimo/app.py

@@ -0,0 +1,26 @@
+from typing import Annotated, Callable, Coroutine
+from fastapi.responses import HTMLResponse, RedirectResponse
+import marimo
+from fastapi import FastAPI, Form, Request, Response
+
+
+# Create a marimo asgi app
+server = (
+    marimo.create_asgi_app()
+    .with_app(path="", root="./index.py")
+    .with_app(path="/bc", root="./bomb_calorimetry.py")
+    .with_app(path="/cv", root="./crystal_violet.py")
+    .with_app(path="/stats", root="./statistics_lab.py")
+    .with_app(path="/surface", root="./surface_adsorption.py")
+)
+
+# Create a FastAPI app
+app = FastAPI()
+
+app.mount("/", server.build())
+
+# Run the server
+if __name__ == "__main__":
+    import uvicorn
+
+    uvicorn.run(app, host="0.0.0.0", port=8000)

marimo/bomb_calorimetry.py

@@ -0,0 +1,140 @@
+import marimo
+
+__generated_with = "0.11.0"
+app = marimo.App(width="medium")
+
+
+@app.cell
+def _():
+    import marimo as mo
+    import pycek_public as cek
+    lab = cek.bomb_calorimetry(make_plots=True)
+    return cek, lab, mo
+
+
+@app.cell
+def _(mo):
+    mo.md(
+        """
+        #Bomb calorimetry lab
+
+        This notebook mimics a bomb calorimetry laboratory experiment.
+        In each experiment a tablet of reactant is prepared and combusted in the calorimeter.
+        During the experiment the temperature inside the calorimeter is monitored.
+
+        ## Obejectives
+        1. Calibration of the calorimeter
+        2. Calculation of enthalpy of combustion of sucrose
+        3. Calculation of enthalpy of combustion of napthalene
+
+        ## Instructions
+        1. Type your student ID
+        2. Select a sample
+        3. Click "Run Experiment"
+        4. Perform at least 4 experiments per sample
+        ___
+        """
+    )
+    return
+
+
+@app.cell
+def _(lab, mo):
+    def set_ID(value):
+        try:
+            student_number = int(value)
+            if student_number <= 0:
+                print(mo.md(f"### Invalid Student ID: {student_ID.value}"))
+            else:
+                print(f"Valid Student ID: {student_number}")
+                lab.set_student_ID(int(value))
+        except ValueError:
+            print(mo.md(f"### Invalid Student ID: {student_ID.value}"))
+
+    student_ID = mo.ui.text(value="", label="Student ID:",on_change=set_ID)
+
+    def set_fname(value):
+        lab._set_filename(value)
+
+    exp_ID = mo.ui.text(value="Automatic", label="Output file:", 
+                        on_change=set_fname)
+
+    sample_selector = mo.ui.dropdown(
+        options=lab.available_samples, value=None, label="Select sample:"
+    )
+
+    run_button = mo.ui.run_button(label="Run Experiment")
+    reset_button = mo.ui.run_button(label="Reset Counter")
+
+    # Create download button using marimo's download function
+
+    mo.vstack([student_ID, exp_ID, sample_selector, run_button, reset_button])
+    return (
+        exp_ID,
+        reset_button,
+        run_button,
+        sample_selector,
+        set_ID,
+        set_fname,
+        student_ID,
+    )
+
+
+@app.cell
+def _(cek, lab, mo, reset_button, run_button, sample_selector, student_ID):
+    if reset_button.value:
+        lab.ID = 0
+        lab._set_filename(None)
+
+    image = ""
+    message = ""
+    download_button = ""
+    if run_button.value:
+        mo.stop(not student_ID.value.isdigit(), mo.md(f"### Invalid Student ID: {student_ID.value}"))
+        mo.stop(sample_selector.value is None, mo.md(f"### No sample selected !!"))
+
+        lab.set_parameters(sample=sample_selector.value,precision=0.01)
+        _ = lab.create_data()
+        fname = lab.write_data_to_file()
+        
+        with open(fname, "r") as f:
+            file_content = f.read()
+        message = f"### Running Experiment\n"
+        for k,v in lab.metadata.items():
+            message += f"####{k} = {v}\n"
+        message += f"#### File created = {fname}\n"
+
+        download_button = mo.download(
+            file_content,
+            filename=fname,
+            label=f"Download {fname}",
+        )
+
+        plot = cek.plotting()
+        data,_,_ = lab.read_data_file(fname)
+        plot.quick_plot(data,output=fname.replace(".csv",".png"))
+        image = mo.image(fname.replace(".csv",".png"),width=500)
+        
+    mo.vstack([mo.md(message),download_button,image])
+    return (
+        data,
+        download_button,
+        f,
+        file_content,
+        fname,
+        image,
+        k,
+        message,
+        plot,
+        v,
+    )
+
+
+@app.cell
+def _():
+    import numpy as np
+    return (np,)
+
+
+if __name__ == "__main__":
+    app.run()

marimo/crystal_violet.py

@@ -0,0 +1,167 @@
+import marimo
+
+__generated_with = "0.11.0"
+app = marimo.App(width="medium")
+
+
+@app.cell
+def _():
+    import marimo as mo
+    import pycek_public as cek
+    lab = cek.crystal_violet(make_plots=True)
+    return cek, lab, mo
+
+
+@app.cell
+def _(mo):
+    mo.md(
+        """
+        # Crystdal Violet Lab
+
+        This notebook mimics a kinetics laboratory experiment, where a UV-Vis spectrophotometer is used to measure the absorbance as the reaction between crystal violet and hydroxide proceeds. 
+        The absorbance versus time data can then be used to determine the rate of the reaction with respect to both crystal violet and hydroxide ions.
+
+        ## Objectives
+        1. Determine the reaction order with respect to CV
+        2. Determine the reaction order with respect to hydroxide
+        3. Determine the rate constant for the overall reaction
+        4. Determine the activation energy
+
+
+        ## Instructions
+        1. Type your student ID
+        2. Select the volumes of the CV solution, the hydroxide solution and DI water to use
+        3. Select the temperature of the experiment
+        4. Click "Run Experiment"
+        5. Perform two sets of at least three experiments each:
+           - constant [CV] while the [OH$^-$] is varied
+           - constant [OH$^-$] while the [CV] is varied
+        6. Obtain another set of data where the temperature is changed and compute the activation energy and pre-exponential factor
+        ___
+        """
+    )
+    return
+
+
+@app.cell
+def _(lab, mo):
+    def set_ID(value):
+        try:
+            student_number = int(value)
+            if student_number <= 0:
+                print(mo.md(f"### Invalid Student ID: {student_ID.value}"))
+            else:
+                print(f"Valid Student ID: {student_number}")
+                lab.set_student_ID(int(value))
+        except ValueError:
+            print(mo.md(f"### Invalid Student ID: {student_ID.value}"))
+
+    student_ID = mo.ui.text(value="", label="Student ID:",on_change=set_ID)
+
+    def set_fname(value):
+        lab._set_filename(value)
+    exp_ID = mo.ui.text(value="Automatic", label="Output file:", on_change=set_fname)
+
+    cv_volume = mo.ui.number(start=0,stop=100,step=1,value=None,label="Volume of CV solution (mL)")
+    oh_volume = mo.ui.number(start=0,stop=100,step=1,value=None,label="Volume of OH solution (mL)")
+    h2o_volume = mo.ui.number(start=0,stop=100,step=1,value=None,label="Volume of DI water (mL)")
+    temperature = mo.ui.number(start=0,stop=100,step=1,value=25,label="Temperature (C)")
+    run_button = mo.ui.run_button(label="Run Experiment")
+    reset_button = mo.ui.run_button(label="Reset Counter")
+
+    # Create download button using marimo's download function
+
+    mo.vstack([student_ID, 
+               exp_ID, 
+               cv_volume, 
+               oh_volume, 
+               h2o_volume, 
+               temperature,
+               run_button, 
+               reset_button])
+    return (
+        cv_volume,
+        exp_ID,
+        h2o_volume,
+        oh_volume,
+        reset_button,
+        run_button,
+        set_ID,
+        set_fname,
+        student_ID,
+        temperature,
+    )
+
+
+@app.cell
+def _(
+    cek,
+    cv_volume,
+    h2o_volume,
+    lab,
+    mo,
+    oh_volume,
+    reset_button,
+    run_button,
+    student_ID,
+    temperature,
+):
+    if reset_button.value:
+        lab.ID = 0
+        lab._set_filename(None)
+
+    image = ""
+    message = ""
+    download_button = ""
+    if run_button.value:
+        mo.stop(not student_ID.value.isdigit(), mo.md(f"### Invalid Student ID: {student_ID.value}"))
+
+        cv_vol = cv_volume.value
+        oh_vol = oh_volume.value
+        h2o_vol = h2o_volume.value
+
+        lab.set_parameters(
+            volumes={'cv': cv_vol, 'oh': oh_vol, 'h2o': h2o_vol},
+            temperature=temperature.value+273.15
+        )
+        _ = lab.create_data()
+        fname = lab.write_data_to_file()
+        
+        with open(fname, "r") as f:
+            file_content = f.read()
+        message = f"### Running Experiment\n"
+        for k,v in lab.metadata.items():
+            message += f"####{k} = {v}\n"
+        message += f"#### File created = {fname}\n"
+
+        download_button = mo.download(
+            file_content,
+            filename=fname,
+            label=f"Download {fname}",
+        )
+
+        plot = cek.plotting()
+        data,_,_ = lab.read_data_file(fname)
+        plot.quick_plot(data,output=fname.replace(".csv",".png"))
+        image = mo.image(fname.replace(".csv",".png"),width=500)
+        
+    mo.vstack([mo.md(message),download_button,image])
+    return (
+        cv_vol,
+        data,
+        download_button,
+        f,
+        file_content,
+        fname,
+        h2o_vol,
+        image,
+        k,
+        message,
+        oh_vol,
+        plot,
+        v,
+    )
+
+
+if __name__ == "__main__":
+    app.run()

marimo/index.py

@@ -0,0 +1,23 @@
+import marimo
+
+__generated_with = "0.11.0"
+app = marimo.App(width="medium")
+
+
+@app.cell
+def _():
+    import marimo as mo
+
+@app.cell
+def _(mo):
+    mo.md(
+        """
+        #Labs
+
+        1. [Bomb Calorimetry](/bc)
+        2. [Crystal Violet](/cv)
+        3. [Statistics](/stats)
+        4. [Surface Adsorption](/surface)
+        """
+    )
+    return

marimo/statistics_lab.py

@@ -0,0 +1,140 @@
+import marimo
+
+__generated_with = "0.11.0"
+app = marimo.App(width="medium")
+
+
+@app.cell
+def _():
+    import marimo as mo
+    import pycek_public as cek
+    lab = cek.stats_lab(make_plots=True)
+    return cek, lab, mo
+
+
+@app.cell
+def _(mo):
+    mo.md(
+        """
+        # Statistics lab
+        This numerical lab consists a few small tasks, which cover the key statistics topics that were introduced in the previous chapter.
+        They are also preparatory for the following labs, where you would have to use the same concepts in more complicated situations.
+        In particular, if you are using python, it would be beneficial to solve some of this exercises by creating specific functions that can the be reused (maybe with small modifications) in the following labs.
+
+        ## Tasks
+        1. Average and standard error
+        2. Propagation of uncertainty
+        3. Comparison of averages
+        4. Linear Fit
+        5. Non linear fit
+        6. Outlier detection
+
+
+        ## Instructions
+        1. Type your student ID
+        2. Select a task
+        3. Click "Run Experiment"
+        4. Analysed the data
+        ___
+        """
+    )
+    return
+
+
+@app.cell
+def _(lab, mo):
+    def set_ID(value):
+        try:
+            student_number = int(value)
+            if student_number <= 0:
+                print(mo.md(f"### Invalid Student ID: {student_ID.value}"))
+            else:
+                print(f"Valid Student ID: {student_number}")
+                lab.set_student_ID(int(value))
+        except ValueError:
+            print(mo.md(f"### Invalid Student ID: {student_ID.value}"))
+
+    student_ID = mo.ui.text(value="", label="Student ID:",on_change=set_ID)
+
+    def set_fname(value):
+        lab._set_filename(value)
+
+    exp_ID = mo.ui.text(value="Automatic", label="Output file:", 
+                        on_change=set_fname)
+
+    sample_selector = mo.ui.dropdown(
+        options=lab.available_samples, value=None, label="Select task:"
+    )
+
+    run_button = mo.ui.run_button(label="Run Experiment")
+    reset_button = mo.ui.run_button(label="Reset Counter")
+
+    # Create download button using marimo's download function
+
+    mo.vstack([student_ID, exp_ID, sample_selector, run_button, reset_button])
+    return (
+        exp_ID,
+        reset_button,
+        run_button,
+        sample_selector,
+        set_ID,
+        set_fname,
+        student_ID,
+    )
+
+
+@app.cell
+def _(cek, lab, mo, reset_button, run_button, sample_selector, student_ID):
+    if reset_button.value:
+        lab.ID = 0
+        lab._set_filename(None)
+
+    image = ""
+    message = ""
+    download_button = ""
+    if run_button.value:
+        mo.stop(not student_ID.value.isdigit(), mo.md(f"### Invalid Student ID: {student_ID.value}"))
+        mo.stop(sample_selector.value is None, mo.md(f"### No sample selected !!"))
+
+        lab.set_parameters(
+            number_of_values = 12,
+            sample=sample_selector.value
+        )
+        _ = lab.create_data()
+        fname = lab.write_data_to_file()
+
+        with open(fname, "r") as f:
+            file_content = f.read()
+        message = f"### Running Experiment\n"
+        for k,v in lab.metadata.items():
+            message += f"####{k} = {v}\n"
+        message += f"#### File created = {fname}\n"
+
+        download_button = mo.download(
+            file_content,
+            filename=fname,
+            label=f"Download {fname}",
+        )
+
+        plot = cek.plotting()
+        data,_,_ = lab.read_data_file(fname)
+        plot.quick_plot(data,output=fname.replace(".csv",".png"))
+        image = mo.image(fname.replace(".csv",".png"),width=500)
+
+    mo.vstack([mo.md(message),download_button,image])
+    return (
+        data,
+        download_button,
+        f,
+        file_content,
+        fname,
+        image,
+        k,
+        message,
+        plot,
+        v,
+    )
+
+
+if __name__ == "__main__":
+    app.run()

marimo/surface_adsorption.py

@@ -0,0 +1,137 @@
+import marimo
+
+__generated_with = "0.11.0"
+app = marimo.App(width="medium")
+
+
+@app.cell
+def _():
+    import marimo as mo
+    import pycek_public as cek
+    lab = cek.cek.surface_adsorption(make_plots=True)
+    return cek, lab, mo
+
+
+@app.cell
+def _(mo):
+    mo.md(
+        """
+        # Surface Adsorption Lab
+
+        In the virtual laboratory below, we will be looking at the adsorption of the dye Acid Blue 158 on chitin in water. 
+        The simulated experiments mimic different conditions and will be used to determine the enthalpy of adsorption of the dye on the substrate.
+        The output file contains the concentration of the dye left in solution, as a function of the amount that was added to the beaker with the kitin powder.
+
+        ## Objectives
+        1. Calculation of the Langmuir constant ($K_L$) and the monolayer coverage ($Q$) at different temperatures
+        2. Compare the fitted values obtained from fitting both forms of the Langmuir isotherm (linear and non-linear)
+        3. alculation of the adsorption enthalpy
+        4. Comparison with the provided experimental value
+
+        ## Instructions
+        1. Type your student ID
+        2. Select the volumes of the CV solution, the hydroxide solution and DI water to use
+        3. Select the temperature of the experiment
+        4. Click "Run Experiment"
+        5. Perform at least 5 experiments at different temperatures
+        ___
+        """
+    )
+    return
+
+
+@app.cell
+def _(lab, mo):
+    def set_ID(value):
+        try:
+            student_number = int(value)
+            if student_number <= 0:
+                print(mo.md(f"### Invalid Student ID: {student_ID.value}"))
+            else:
+                print(f"Valid Student ID: {student_number}")
+                lab.set_student_ID(int(value))
+        except ValueError:
+            print(mo.md(f"### Invalid Student ID: {student_ID.value}"))
+
+    student_ID = mo.ui.text(value="", label="Student ID:",on_change=set_ID)
+
+    def set_fname(value):
+        lab._set_filename(value)
+    exp_ID = mo.ui.text(value="Automatic", label="Output file:", on_change=set_fname)
+
+    temperature = mo.ui.number(start=0,stop=100,step=1,value=25,label="Temperature (C)")
+
+    run_button = mo.ui.run_button(label="Run Experiment")
+    reset_button = mo.ui.run_button(label="Reset Counter")
+
+    # Create download button using marimo's download function
+
+    mo.vstack([student_ID, 
+               exp_ID, 
+               temperature,
+               run_button, 
+               reset_button])
+    return (
+        exp_ID,
+        reset_button,
+        run_button,
+        set_ID,
+        set_fname,
+        student_ID,
+        temperature,
+    )
+
+
+@app.cell
+def _(cek, lab, mo, reset_button, run_button, student_ID, temperature):
+    if reset_button.value:
+        lab.ID = 0
+        lab._set_filename(None)
+
+    image = ""
+    message = ""
+    download_button = ""
+    if run_button.value:
+        mo.stop(not student_ID.value.isdigit(), mo.md(f"### Invalid Student ID: {student_ID.value}"))
+
+        lab.set_parameters(
+            temperature = temperature.value+273.15
+        )
+        _ = lab.create_data()
+        fname = lab.write_data_to_file()
+        
+        with open(fname, "r") as f:
+            file_content = f.read()
+        message = f"### Running Experiment\n"
+        for k,v in lab.metadata.items():
+            message += f"####{k} = {v}\n"
+        message += f"#### File created = {fname}\n"
+
+        download_button = mo.download(
+            file_content,
+            filename=fname,
+            label=f"Download {fname}",
+        )
+
+        plot = cek.plotting()
+        data,_,_ = lab.read_data_file(fname)
+        plot.quick_plot(data,output=fname.replace(".csv",".png"))
+        image = mo.image(fname.replace(".csv",".png"),width=500)
+        
+    mo.vstack([mo.md(message),download_button,image])
+    return (
+        data,
+        download_button,
+        f,
+        file_content,
+        fname,
+        image,
+        k,
+        message,
+        plot,
+        v,
+    )
+
+
+if __name__ == "__main__":
+    app.run()

pyproject.toml

@@ -0,0 +1,31 @@
+[build-system]
+requires = ["setuptools >= 61.0", "wheel", "numpy"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[project]
+name = "pycek"
+version = "1.0.0"
+requires-python = ">= 3.8"
+authors = [
+  {name = "Paolo Raiteri", email = "p.raiteri@curtin.edu.au"},
+]
+description = "read and write coordinates"
+license = {file = "LICENSE"}
+readme = {file = "README.md", content-type = "text/markdown"}
+dependencies = [
+    "numpy",
+    "scipy",
+    "lmfit",
+    "matplotlib",
+]
+
+[project.optional-dependencies]
+dev = [
+    "black",
+    "mypy",
+    "pylint",
+    "alive-progress",
+] 

src/pycek_public.egg-info/PKG-INFO

@@ -0,0 +1,42 @@
+Metadata-Version: 2.2
+Name: pycek_public
+Version: 1.0.0
+Summary: read and write coordinates
+Author-email: Paolo Raiteri <p.raiteri@curtin.edu.au>
+License: MIT License
+        
+        Copyright (c) 2025 Paolo Raiteri
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: scipy
+Requires-Dist: lmfit
+Requires-Dist: matplotlib
+Provides-Extra: dev
+Requires-Dist: black; extra == "dev"
+Requires-Dist: mypy; extra == "dev"
+Requires-Dist: pylint; extra == "dev"
+Requires-Dist: alive-progress; extra == "dev"
+
+# pycek
+python package for CHEM2000

src/pycek_public.egg-info/SOURCES.txt

@@ -0,0 +1,17 @@
+LICENSE
+README.md
+pyproject.toml
+src/pycek_public/__init__.py
+src/pycek_public/bomb_calorimetry.py
+src/pycek_public/cek_labs.py
+src/pycek_public/crystal_violet.py
+src/pycek_public/generate_random_filenames.py
+src/pycek_public/logger.py
+src/pycek_public/plotting.py
+src/pycek_public/statistics_lab.py
+src/pycek_public/surface_adsorption.py
+src/pycek_public.egg-info/PKG-INFO
+src/pycek_public.egg-info/SOURCES.txt
+src/pycek_public.egg-info/dependency_links.txt
+src/pycek_public.egg-info/requires.txt
+src/pycek_public.egg-info/top_level.txt

src/pycek_public.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

src/pycek_public.egg-info/requires.txt

@@ -0,0 +1,10 @@
+numpy
+scipy
+lmfit
+matplotlib
+
+[dev]
+black
+mypy
+pylint
+alive-progress

src/pycek_public.egg-info/top_level.txt

@@ -0,0 +1 @@
+pycek_public

src/pycek_public/__init__.py

@@ -0,0 +1,12 @@
+from .cek_labs import *
+
+from .generate_random_filenames import *
+from .logger import *
+
+from .statistics_lab import *
+from .bomb_calorimetry import *
+from .crystal_violet import *
+from .surface_adsorption import *
+
+from .plotting import *
+

src/pycek_public/bomb_calorimetry.py

@@ -0,0 +1,113 @@
+import pycek_public as cek
+import numpy as np
+import pprint as pp
+
+class bomb_calorimetry(cek.cek_labs):
+    def setup_lab(self):
+        """
+        Define base information for the lab
+        """
+        self.add_metadata( 
+            laboratory = 'Bomb Calorimetry',
+            columns = ["Time (s)","Temperature (K)"]
+            )
+
+        self.available_samples = ['benzoic', 'sucrose', 'naphthalene']
+
+        self.ignition_time = 20
+        self.relaxation_time = 3
+        self.number_of_values = 100
+        self.noise_level = 0.1
+
+        self.slope_before = np.random.uniform(0., self.noise_level) / 3
+        self.slope_after = np.random.uniform(0., self.noise_level) / 3
+        
+        self.RT = self.R * self.temperature
+        
+        # calorimeter constant (J/K)
+        self.calorimeter_constant = {'value':10135,'std_error':0.0}
+        self.sample_parameters["co2"] = {
+            "mM" : 44.01,
+            "dH" : -393.51e3, # co2 enthapy of formation (J/mol/K)
+        }
+        self.sample_parameters["h2o"] = {
+            "mM" : 18.015,
+            "dH" : -285.83e3,# h2o enthapy of formation (J/mol/K)
+        }    
+            
+        self.sample_parameters["benzoic"] = {
+            "mM" : 122.123,
+            "n1" : 7,
+            "n2" : 3,
+            "dn" : 7-15/2,
+            "dHf" : {'value':-384.8e3,'std_error':0.5e3},
+            "dHc" : {'value':-3227.26e3,'std_error':0.2e3},
+        }
+        self.sample_parameters["sucrose"] = {
+            "mM" : 342.3,
+            "n1" : 12,
+            "n2" : 11,
+            "dn" : 0,
+            "dHf" : {'value':-2221.2e3,'std_error':0.2e3},
+            "dHc" : {'value':-5643.4e3,'std_error':1.8e3},
+        }
+        self.sample_parameters["naphthalene"] = {
+            "mM" : 128.17,
+            "n1" : 10,
+            "n2" : 4,
+            "dn" : 10 - 12,
+            "dHf" : {'value':77e3,'std_error':10.0e3},
+            "dHc" : {'value':-5160e3,'std_error':20.0e3},
+        }
+
+    def create_data(self):
+        """
+        Generate the data
+        """
+        if self.sample is None:
+            raise Exception("Sample not defined")
+
+        prm = self.sample_parameters[ self.sample ]
+
+        self.set_parameters( 
+            sample = self.sample,
+            number_of_values = self.number_of_values,
+            )
+
+        self.mass = np.random.normal(1000, 100)
+        self.add_metadata(**{
+            'Tablet mass (mg)': self.mass,
+            "Ignition time (s)" : self.ignition_time,
+            "Sample" : self.sample, 
+            })
+
+        moles = self.mass / 1000 / prm["mM"]
+
+        # combustion enthalpy
+        # nH{co2} + mH{h2o} - H = DcH
+        DcH = prm["n1"] * self.sample_parameters["co2"]["dH"] + \
+              prm["n2"] * self.sample_parameters["h2o"]["dH"] - prm["dHf"]["value"]
+
+        dH = DcH * moles
+        dnrt = moles * self.RT * prm["dn"]
+        dU = dH - dnrt
+        
+        deltaT = -dU / self.calorimeter_constant['value']
+
+        x = np.linspace(0, self.number_of_values, self.number_of_values)
+        y = np.random.normal(0, self.noise_level, self.number_of_values)
+
+        dd = 0.
+        T = self.temperature
+        for i in range(self.number_of_values):
+            if i < self.ignition_time:
+                T += self.slope_before 
+            else:   
+                T += self.slope_after
+                dd = deltaT * (1 - np.exp( - (i - self.ignition_time) / self.relaxation_time) )
+            y[i] += T + dd 
+
+        self.data = np.column_stack((x,y))
+
+        return
+

src/pycek_public/cek_labs.py

@@ -0,0 +1,388 @@
+import pycek_public as cek
+import numpy as np
+from collections import OrderedDict
+
+from abc import ABC, abstractmethod
+class cek_labs(ABC):
+    def __init__(self, **kwargs):        
+        self.token = None
+        self.student_ID = 123456789
+
+        self.noise_level = 1
+        self.precision = 1
+        
+        self.available_samples = []
+        self.sample_parameters = {}
+        self.sample = None
+
+        self.R = 8.314
+        self.NA = 6.022e23
+        self.temperature = 298
+
+        self.number_of_values = 100
+        self.output_file = None
+        self.filename_gen = cek.TempFilenameGenerator()
+
+        self.metadata = OrderedDict({
+            'student_ID' : self.student_ID,
+            'number_of_values' : self.number_of_values,
+            'output_file' : self.output_file,
+        })
+        
+        self.logger_level = "ERROR"
+
+        # Define some lab specific parameters
+        # Can overwrite the defaults
+        for k,w in kwargs.items():
+            setattr(self, k, w)
+        np.random.seed(self.student_ID)
+
+        self.logger = cek.setup_logger(level=self.logger_level)
+        # self.logger.debug("This is a debug message")
+        # self.logger.verbose("This is a verbose message")  # New verbose level
+        # self.logger.info("This is an info message")
+        # self.logger.result("This is an result message")
+        # self.logger.warning("This is a warning message")
+        # self.logger.error("This is an error message")
+        # self.logger.critical("This is a critical message")
+        # quit()
+
+        # Lab specific parameters
+        self.setup_lab()
+
+    def __str__(self):
+        return f'CHEM2000 Lab: {self.__class__.__name__}'
+
+    def set_student_ID(self,student_ID):
+        if isinstance(student_ID,int):
+            self.student_ID = student_ID
+        elif isinstance(student_ID,str):
+            if student_ID.isdigit():
+                self.student_ID = int(student_ID)
+            else:
+                raise ValueError("student_ID must be an integer")
+        else:
+            raise ValueError("student_ID must be an integer")
+        np.random.seed(self.student_ID)
+        self.update_metadata_from_attr()
+        self.logger.debug(f"Initial seed = {np.random.get_state()[1][0]}")
+
+    def set_token(self, token):
+        self.token = token
+        #print(f"Check: {self._check_token()}")
+
+    def _check_token(self):
+        if self.token != 23745419:
+            return True
+        return False
+
+    def add_metadata(self, **kwargs):
+        for key, value in kwargs.items():
+            self.metadata[key] = value
+        return
+    
+    def update_metadata_from_attr(self):
+        for k in self.metadata:
+            try:
+                self.metadata[k] = getattr(self, k)
+            except:
+                pass
+        return
+    
+    def set_parameters(self, **kwargs):
+        """
+        Set parameters for the lab
+        """
+        for k,w in kwargs.items():
+            if k == "student_ID":
+                self.set_student_ID(w)
+            else:
+                setattr(self, k, w)
+        self.update_metadata_from_attr()
+        return
+
+    def write_metadata(self,f=None):
+        """
+        Write metadata to the data file
+        """
+        if f is None:
+            def dump(s):
+                self.logger.info(s)
+        else:
+            def dump(s):
+                with open(f, 'a') as file:
+                    file.write(f"# {s}\n")
+
+        for key, value in self.metadata.items():
+            string = f"{key}"
+            string = string.replace("_"," ")
+            string = string[0].upper() + string[1:] + f" = {value}"
+            dump(string)
+
+    def read_metadata(self,f):
+        """
+        Read metadata from the data file
+        
+        Return: metadata (dict)
+        """
+        metadata = OrderedDict({})
+
+        hash_lines = []
+        with open(f, 'r') as file:
+            for line in file:
+                if line.strip().startswith('#'):
+                    hash_lines.append(line.replace('#','').strip())
+        
+        for l in hash_lines:
+            if ":" in l:
+                key, value = l.split(':')
+            elif "=" in l:
+                key, value = l.split('=')
+            else:
+                raise Exception("Unknown separator")
+            key = key.replace("#","").strip()
+            metadata[key] = value.strip()
+            
+        return metadata
+
+    def write_data_to_file(self, **kwargs):
+        """
+        """
+        if self.output_file is None:
+            filename = self.filename_gen.random
+        else:
+            filename = self.output_file
+        self.add_metadata(output_file=filename)
+
+        with open(filename, 'w') as f:
+            # Write the column names
+            cols = None
+            if "columns" in kwargs:
+                cols = kwargs["columns"]
+            elif "columns" in self.metadata:
+                cols = self.metadata["columns" ]
+            if cols is not None:
+                f.write(",".join(cols) + "\n")
+
+            # Convert NumPy array to list if needed
+            # if isinstance(self.data, np.ndarray):
+            #     self.data = self.data.tolist()
+
+            # Write data
+            for row in self.data:
+                # Handle multiple columns
+                if isinstance(row, (list, tuple, np.ndarray)):
+                    line = ",".join(map(str, row))
+                # Handle single-column case
+                else:
+                    line = str(row)
+                f.write(line + "\n")
+
+        # Write the kwargs as metadata
+        self.write_metadata(filename)
+
+        return filename
+
+    def read_data_file(self,filename=None):
+        if filename is None:
+            raise ValueError("Filename is missing")
+
+        # Read file and separate comments from data
+        comments = []
+        data_lines = []
+
+        with open(filename, "r") as f:
+            for line in f:
+                if line.startswith("#"):
+                    comments.append(line.strip())  # Store comment lines
+                else:
+                    data_lines.append(line.strip())  # Store data lines
+
+        # Extract header and data
+        header = data_lines[0]  # First non-comment line is the header
+        data_lines = "\n".join(data_lines[0:])  # Join remaining lines as CSV data
+
+        # Convert CSV data to NumPy array
+        from io import StringIO
+        from numpy.lib.recfunctions import structured_to_unstructured
+
+        data = np.genfromtxt(
+            StringIO(data_lines), delimiter=',', 
+            comments='#', names=True, 
+            skip_header=0, dtype=None)   
+        
+        data_array = structured_to_unstructured(data)
+
+        metadata = None
+        if len(comments) > 0:
+            metadata = OrderedDict({})
+            for l in comments:
+                if ":" in l:
+                    key, value = l.split(':')
+                elif "=" in l:
+                    key, value = l.split('=')
+                else:
+                    raise Exception("Unknown separator")
+                key = key.replace("#","").strip()
+                metadata[key.strip()] = value.strip()
+
+        # Output results
+        # print("Comments:")
+        # print("\n".join(comments))
+        # print("\nExtracted Data:")
+        # print(data_array)
+        return data_array, header, metadata
+
+    def process_file(self, filename=None):
+        self.read_data(filename)
+        result = self.process_data()
+        return result
+    
+    def _valid_ID(self,ID):
+        if ID in ["23745411"]:
+            return True
+        return False
+        
+    def _round_values(self, values, precision=None):
+        if precision is None:
+            precision = self.precision
+        rounded_values = [round(v, precision) for v in values]
+        values = np.array(rounded_values, dtype=float)
+        return values
+    
+    def _generate_uniform_random(self, lower, upper, n):
+        return self._round_values(np.random.uniform(lower, upper, n))
+
+    def _generate_normal_random(self,n,prm):
+        list_of_1d_arrays = []
+        for p in prm:
+            values = np.random.normal(p[0], p[1], size=n)
+            list_of_1d_arrays.append(self._round_values(values))
+
+        if len(prm) == 1:
+            return np.array(self._round_values(values))
+        else:
+            return np.column_stack( [*list_of_1d_arrays] )
+
+    def _generate_noise(self,n,noise_level=None,ntype="normal"):
+        if noise_level == None:
+            raise ValueError("Missing noise level")
+        if noise_level <= 0:
+            return np.zeros(n)
+        if ntype == "normal":
+            return np.random.normal(0, noise_level, size=n)
+
+    def _generate_data_from_function(self, func, params, nvalues, xrange):
+        x = np.sort(self._generate_uniform_random(nvalues,*xrange))
+        y = func(x, *params) + self._generate_noise(nvalues)
+        y = self._round_values(y)
+        return np.column_stack((x,y))
+
+    import numpy as np
+    from typing import Callable, Dict, Optional, Union, Tuple
+
+    def generate_data_from_function(
+        self,
+        function: Callable,
+        params: Dict,
+        nvalues: int,
+        xrange: Optional[Tuple[float, float]] = None,
+        xspacing: str = 'random',
+        noise_level: Optional[float] = None,
+        background: Optional[float] = None,
+        weights: Optional[bool] = None,
+        positive: bool = False
+    ) -> np.ndarray:
+        """
+        Generate synthetic data points from a given function with optional noise and background.
+
+        Parameters
+        ----------
+        function : callable
+            The model function to generate data from. Should accept x values and **kwargs.
+        params : dict
+            Parameters to pass to the function as keyword arguments.
+        nvalues : int
+            Number of data points to generate.
+        xrange : tuple of float, optional
+            Range of x values (min, max). Required if generating data points.
+        xspacing : str, default='random'
+            Method to space x values. Options:
+            - 'linear': Evenly spaced points
+            - 'random': Uniformly distributed random points
+        noise_level : float, optional
+            Standard deviation of Gaussian noise to add to y values.
+        background : float, optional
+            Constant background level to add to all y values.
+        weights : bool, optional
+            If True, include weights in output (NOT IMPLEMENTED).
+        positive : bool, default=False
+            If True, take absolute value of final y values.
+
+        Returns
+        -------
+        np.ndarray
+            2D array with shape (nvalues, 2) containing (x, y) pairs.
+
+        Raises
+        ------
+        ValueError
+            If xrange is None or invalid xspacing type is provided.
+        """
+        # Validate inputs
+        if xrange is None:
+            raise ValueError("xrange must be provided as (min, max) tuple")
+        
+        if not isinstance(nvalues, int) or nvalues <= 0:
+            raise ValueError("nvalues must be a positive integer")
+
+        # Generate x values
+        if xspacing == "linear":
+            x = np.linspace(*xrange, nvalues)
+        elif xspacing == "random":
+            x = np.sort(self._generate_uniform_random(*xrange, nvalues))
+        else:
+            raise ValueError(f"xspacing must be 'linear' or 'random', got '{xspacing}'")
+
+        # Generate base y values from function
+        y = function(x, **params)
+
+        # Add optional modifications
+        if background is not None:
+            y += background
+        
+        if noise_level is not None:
+            y += self._generate_noise(nvalues,noise_level)
+        
+        if positive:
+            y = np.abs(y)
+
+        # Note: weights parameter is currently unused
+        if weights is not None:
+            # TODO: Implement weights handling
+            pass
+
+        y = self._round_values(y)
+
+        return np.column_stack((x, y))
+
+    def create_data_file(self):
+        data = self.create_data()
+        self.write_data_to_file(
+            self.metadata['output_file'], 
+            data, **self.metadata )
+        return self.metadata['output_file']
+    
+    def get_data(self):
+        return self.data
+    def get_metadata(self):
+        return self.metadata
+
+    @abstractmethod
+    def setup_lab(self,**kwargs):
+        pass
+
+    @abstractmethod
+    def create_data(self):
+        pass
+

src/pycek_public/crystal_violet.py

@@ -0,0 +1,75 @@
+import pycek_public as cek
+import numpy as np
+
+class crystal_violet(cek.cek_labs):
+    def setup_lab(self):
+        """
+        Define base information for the lab.
+        They can be overwrite by the user using the kwargs in the constructor or
+        by calling the set_parameters method.
+        """
+        self.add_metadata( 
+            laboratory = 'Crystal Violet Lab',
+            columns = ["Time (s)","Absorbance"]
+            )
+
+        self.expt_time = 1000
+        self.number_of_values = 501
+        self.noise_level = 0.1
+        self.precision = 4
+        
+        self.activation_energy = 63e3 # J/mol
+        self.prefactor = 5.9e9 # 1/M/s
+        
+        # Order wrt CV and OH
+        self.alpha = 1.0
+        self.beta = 0.75
+        self.conc_to_abs = 160e3 # Absorbivity of CV at 590 nm (L/mol/cm)
+        self.stock_solutions = {"cv" : 2.5e-5, "oh" : 0.5} # mol/L
+        
+        self.volumes = {"cv" : 10, "oh" : 10, "h2o" : 10.0} # mL
+
+    def create_data(self):
+        """
+        Generate the data
+        """
+        self.set_parameters( 
+            sample = self.sample,
+            number_of_values = self.number_of_values,
+            )
+
+        self.add_metadata(**{
+            "Temperature (C)"   : self.temperature-273.15,
+            "Volume of CV (mL)" : self.volumes['cv'],
+            "Volume of OH (mL)" : self.volumes['oh'],
+            "Volume of H2O (mL)": self.volumes['h2o'],
+        })
+
+        vtot = np.sum( [ x + np.random.normal(0,self.noise_level,1) for x in self.volumes.values() ] )
+        initial_concentration_cv = \
+            self.stock_solutions["cv"] * self.volumes["cv"] / vtot
+
+        concetration_oh = \
+            self.stock_solutions["oh"] * self.volumes["oh"] / vtot
+
+        rate_constant = self.prefactor*np.exp(-self.activation_energy/(self.R*(self.temperature)))
+        pseudo_rate_constant = rate_constant * np.power(concetration_oh,self.beta)
+
+        params = {
+            "A" : initial_concentration_cv* self.conc_to_abs,
+            "k" : pseudo_rate_constant    
+        }
+
+        self.data = self.generate_data_from_function(
+                lambda x,A,k: A * np.exp(-k * x) , 
+                params, 
+                self.number_of_values,
+                xrange = [0, self.expt_time], 
+                xspacing = 'linear',
+                noise_level = self.noise_level,
+                positive = True,
+                background = 0.1
+                )
+        
+        return 
+    

src/pycek_public/generate_random_filenames.py

@@ -0,0 +1,166 @@
+import os
+from glob import glob
+import secrets
+import string
+
+class TempFilenameGenerator:
+    """
+    Generates temporary filenames with .pdb extension and increasing indices.
+    Supports both sequential (tmp.{index}.pdb) and random (tmp.{random}.pdb) formats.
+    """
+    def __init__(self, directory=".", root="data", ext="csv", random_length=12):
+        """
+        Initialize the generator with a target directory.
+        
+        Args:
+            directory (str): Directory for the filenames (default: current directory)
+            root (str): Root name for the temporary files (default: tmp)
+            ext (str): File extension (default: pdb)
+            random_length (int): Length of random string in random filenames (default: 12)
+
+        Example:
+            generator = TempFilenameGenerator()
+
+            # Get sequential filename (e.g., "tmp.0.pdb")
+            sequential_file = generator.next
+
+            # Get random filename (e.g., "tmp.j4k3h2l5m9n8.pdb")
+            random_file = generator.random
+        """
+        self.directory = directory
+        self.root = root
+        self.ext = ext
+        self.random_length = random_length
+        self._current_index = self._find_max_index()
+        self._current_filename = None
+
+    def _find_max_index(self):
+        """Find the highest existing index in the directory."""
+        pattern = os.path.join(self.directory, f"{self.root}.*.{self.ext}")
+        existing_files = glob(pattern)
+        
+        if not existing_files:
+            return -1
+            
+        indices = []
+        for filename in existing_files:
+            try:
+                # Extract index from tmp.{index}.pdb
+                index = int(os.path.basename(filename).split('.')[-2])
+                indices.append(index)
+            except (ValueError, IndexError):
+                continue
+                
+        return max(indices) if indices else -1
+
+    def _generate_random_string(self):
+        """Generate a cryptographically secure random string."""
+        alphabet = string.ascii_letters + string.digits
+        return ''.join(secrets.choice(alphabet) for _ in range(self.random_length))
+
+    def delete_files(self):
+        """Delete all temporary files in the directory."""
+        pattern = os.path.join(self.directory, f"{self.root}.*.{self.ext}")
+        for filename in glob(pattern):
+            os.remove(filename)
+        self._current_index = -1
+            
+    def copy_last(self, dest):
+        """Copy the last generated file to a destination."""
+        if self._current_filename is None:
+            raise ValueError("No files have been generated yet")
+        os.system(f"cp {self._current_filename} {dest}")
+        
+    @property
+    def next(self):
+        """Generate the next filename in sequence."""
+        self._current_index += 1
+        filename = f"{self.root}.{self._current_index}.{self.ext}"
+        self._current_filename = os.path.join(self.directory, filename)
+        return self._current_filename
+
+    @property
+    def random(self):
+        """Generate a random filename."""
+        random_string = self._generate_random_string()
+        filename = f"{self.root}.{random_string}.{self.ext}"
+        self._current_filename = os.path.join(self.directory, filename)
+        return self._current_filename
+
+    @property
+    def current_index(self):
+        """Get the current index value."""
+        return self._current_index
+
+    @property
+    def current(self):
+        """Get the current filename."""
+        return self._current_filename
+    
+# import random
+# import string
+# import os
+# from typing import Optional
+
+# def generate_random_filename(
+#     extension: Optional[str] = 'csv',
+#     length: Optional[int] = 10,
+#     prefix: Optional[str] = 'data_',
+#     directory: Optional[str] = '',
+#     existing_check: Optional[bool] = True
+# ) -> str:
+#     """
+#     Generate a random filename with optional parameters.
+    
+#     Args:
+#         extension (str): File extension to append (e.g., '.txt', '.pdf')
+#         length (int): Length of the random string (default: 10)
+#         prefix (str): Prefix to add before the random string
+#         directory (str): Directory path where the file will be created
+#         existing_check (bool): Whether to check if filename already exists
+    
+#     Returns:
+#         str: Generated filename
+        
+#     Raises:
+#         ValueError: If length is less than 1
+#         ValueError: If unable to generate unique filename after 100 attempts
+#     """
+#     if length < 1:
+#         raise ValueError("Length must be at least 1")
+        
+#     # Clean up the extension
+#     if extension and not extension.startswith('.'):
+#         extension = '.' + extension
+        
+#     # Clean up the directory path
+#     if directory:
+#         directory = os.path.abspath(directory)
+#         if not os.path.exists(directory):
+#             os.makedirs(directory)
+            
+#     attempts = 0
+#     max_attempts = 100
+    
+#     while True:
+#         # Generate random string using ASCII letters and digits
+#         random_string = ''.join(
+#             random.choices(string.ascii_letters + string.digits, k=length)
+#         )
+        
+#         # Combine all parts of the filename
+#         filename = f"{prefix}{random_string}{extension}"
+        
+#         # Add directory path if specified
+#         if directory:
+#             filename = os.path.join(directory, filename)
+            
+#         # Check if file exists (if requested)
+#         if not existing_check or not os.path.exists(filename):
+#             return filename
+            
+#         attempts += 1
+#         if attempts >= max_attempts:
+#             raise ValueError(
+#                 f"Unable to generate unique filename after {max_attempts} attempts"
+#             )

src/pycek_public/logger.py

@@ -0,0 +1,112 @@
+import sys
+import logging
+import colorama
+from colorama import Fore, Style
+
+# Initialize colorama to work on Windows too
+colorama.init()
+
+# Define custom VERBOSE level (between DEBUG-10 and INFO-20)
+VERBOSE = 15
+logging.addLevelName(VERBOSE, 'VERBOSE')
+RESULT = 25
+logging.addLevelName(RESULT, 'RESULT')
+
+class ColoredFormatter(logging.Formatter):
+    """Custom formatter that adds colors to log messages based on level with fixed width"""
+    COLORS = {
+        'DEBUG': Fore.CYAN + Style.BRIGHT,
+        'VERBOSE': Fore.BLUE + Style.BRIGHT,
+        'INFO': Fore.GREEN + Style.BRIGHT,
+        'RESULT' : Fore.RESET + Style.BRIGHT,
+        'WARNING': Fore.YELLOW + Style.BRIGHT,
+        'ERROR': Fore.RED + Style.BRIGHT,
+        'CRITICAL': Fore.MAGENTA + Style.BRIGHT
+    }
+    LEVEL_NAME_WIDTH = 8
+
+    def format(self, record):
+        # Save original levelname and message
+        orig_levelname = record.levelname
+        orig_msg = record.msg
+
+        # Determine the color for the level
+        color_code = self.COLORS.get(orig_levelname, '')
+
+        # Calculate padding for levelname
+        padding = ' ' * (self.LEVEL_NAME_WIDTH - len(orig_levelname))
+
+        # Apply color to levelname with padding
+        record.levelname = f"{color_code}{orig_levelname}{padding}{Style.RESET_ALL}"
+
+        # Apply color to the message as well
+        record.msg = f"{color_code}{orig_msg}{Style.RESET_ALL}"
+
+        # Format the message
+        result = super().format(record)
+
+        # Restore original values
+        record.levelname = orig_levelname
+        record.msg = orig_msg
+        return result
+    
+class ColoredLogger(logging.Logger):
+    """Custom logger class with verbose method"""
+    
+    def verbose(self, msg, *args, **kwargs):
+        """Log at custom VERBOSE level"""
+        if self.isEnabledFor(VERBOSE):
+            self._log(VERBOSE, msg, args, **kwargs)
+            
+    def result(self, msg, *args, **kwargs):
+        """Log at custom RESULT level"""
+        if self.isEnabledFor(RESULT):
+            self._log(RESULT, msg, args, **kwargs)
+            
+    # logging.Logger.result = custom_logging
+
+def setup_logger(name='colored_logger', level="INFO"):
+    """Set up and return a colored logger instance"""
+    
+    # Register our custom logger class
+    logging.setLoggerClass(ColoredLogger)
+    
+    # Create logger
+    logger = logging.getLogger(name)
+    
+    # Set logger level
+    try:
+        logger.setLevel(getattr(logging, level.upper()))
+    except AttributeError:
+        logger.setLevel(logging.INFO)  # Default to INFO if invalid level
+    
+    # Create console handler
+    console_handler = logging.StreamHandler(sys.stdout)
+    console_handler.setLevel(level)
+    
+    # Create formatter
+    formatter = ColoredFormatter(
+        # fmt='%(asctime)s - %(levelname)s - %(message)s',
+        # datefmt='%Y-%m-%d %H:%M:%S'
+        fmt='%(levelname)8s - %(message)s'
+    )
+    
+    # Add formatter to handler
+    console_handler.setFormatter(formatter)
+    
+    # Add handler to logger
+    logger.addHandler(console_handler)
+    
+    return logger
+
+# Example usage
+if __name__ == '__main__':
+    logger = setup_logger()
+    
+    # Test all log levels including new VERBOSE level
+    logger.debug("This is a debug message")
+    logger.verbose("This is a verbose message")  # New verbose level
+    logger.info("This is an info message")
+    logger.warning("This is a warning message")
+    logger.error("This is an error message")
+    logger.critical("This is a critical message")

src/pycek_public/plotting.py

@@ -0,0 +1,49 @@
+import matplotlib.pyplot as plt
+import numpy as np
+from scipy import stats
+
+class plotting():
+    def quick_plot(self, scatter=None, line=None, columns=["X","Y"], output=None, hline=None):
+        """
+        Plot the data along with the best fit line and its associated confidence band.
+
+        Parameters:
+            data (list): List of data to plot
+            columns (list): Axes labels (default is "X","Y")
+
+        Returns:
+            None: Displays a matplotlib plot with data, fit line, and confidence band
+
+        Example:
+            >>> quick_plot(x_data, y_data)
+        """
+
+        if scatter is None and line is None:
+            raise ValueError("Either scatter or line should be provided")
+        
+        if not isinstance(scatter,list):
+            scatter = [scatter]
+        if not isinstance(line,list):
+            line = [line]
+
+        # Plot the observed data points as a scatter plot
+        for ds in scatter:
+            plt.scatter(ds[:,0],ds[:,1], color='blue', label='Data')
+
+        # Add labels and title to the plot
+        plt.xlabel(columns[0])
+        plt.ylabel(columns[1])
+        
+        if hline is not None:
+            plt.axhline(hline, color='black', linestyle='--')
+
+        # Display the legend
+        plt.legend()
+
+        # Show the plot
+        if output is None:
+            plt.show()
+        else:
+            plt.savefig(output)
+        plt.close()
+

src/pycek_public/statistics_lab.py

@@ -0,0 +1,121 @@
+import pycek_public as cek
+import numpy as np
+
+class stats_lab(cek.cek_labs):
+    def setup_lab(self):
+        """
+        Define base information for the lab
+        """
+        self.add_metadata( 
+                          laboratory = 'Basic Statistics Lab',
+                          columns = ["X","Y"]
+                          )
+
+        self.available_samples = [
+            'Averages',
+            'Propagation of uncertainty',
+            'Comparison of averages',
+            'Linear fit',
+            'Non linear fit',
+            'Detection of outliers',
+        ]
+    
+        self.sample_parameters['Averages'] = {
+            "gen_values" : [
+                (1.0, 0.1),
+                (12., 2.0)
+            ],
+            'exp_values' : (1.0,9.0),
+            }
+        
+        self.sample_parameters['Propagation of uncertainty'] = {
+            "gen_values" : [
+                (15.0, 1.0),
+                (133., 2.0)
+            ],
+            }
+
+        self.sample_parameters['Comparison of averages'] = {
+            "gen_values" : [
+                (15.0, 1.0),
+                (13.2, 2.0)
+            ],
+            }
+
+        self.sample_parameters['Linear fit'] = {
+            "function" : lambda x,m,q: m*x + q, 
+            "gen_values" : {'m':12.3 , 'q':1.0},
+            "xrange" : [0.0 , 10.0]
+            }
+
+        self.sample_parameters['Non linear fit'] = {
+            "nval" : 10,
+            "function" : lambda x,E0,K0,Kp,V0:  E0 + K0 * x / Kp * ( (V0/x)**Kp / (Kp-1)+1) - K0*V0/(Kp-1), 
+            "gen_values" : {"E0":-634.2, "K0":12.43, "Kp":4.28, "V0":99.11},
+            "xrange" : [50 , 140]
+        }
+        
+        self.sample_parameters['Detection of outliers'] = {
+            "function" : lambda x,m,q: m*x + q, 
+            "gen_values" : {'m':2.3 , 'q':0.1},
+            "xrange" : [10.0 , 20.0],
+            "shift" : 2,
+            }
+        
+    def create_data(self):
+        """
+        Generate the data
+        """
+        if self.sample is None:
+            raise Exception("Sample not defined")
+
+        prm = self.sample_parameters[ self.sample ]
+        
+        self.set_parameters( 
+            number_of_values = self.number_of_values,
+            )
+        
+        if "noise" in prm:
+            self.set_parameters( noise_level = prm["noise"] )
+
+        self.add_metadata(
+            number_of_values = self.number_of_values,
+            sample = self.sample,
+        )
+        
+        if self.sample in ["Averages", 'Propagation of uncertainty', 'Comparison of averages']:
+            data = self._generate_normal_random(self.number_of_values, prm['gen_values'])
+
+        elif self.sample in ["Linear fit"]:
+            data = self.generate_data_from_function(
+                prm["function"], 
+                prm['gen_values'], 
+                self.number_of_values,
+                prm['xrange'], 
+                noise_level = self.noise_level,
+                )
+
+        elif self.sample in ["Non linear fit"]:
+            data = self.generate_data_from_function(
+                prm["function"], 
+                prm['gen_values'], 
+                self.number_of_values,
+                prm['xrange'], 
+                noise_level = self.noise_level,
+                )
+        
+        elif self.sample in ["Detection of outliers"]:
+            data = self.generate_data_from_function(
+                prm["function"], 
+                prm['gen_values'], 
+                self.number_of_values,
+                prm['xrange'], 
+                noise_level = self.noise_level,
+                )
+            i = np.random.randint(self.number_of_values)
+            data[i,1] += prm['shift']
+
+
+        self.data = data
+        return data            
+

src/pycek_public/surface_adsorption.py

@@ -0,0 +1,83 @@
+import pycek_public as cek
+import numpy as np
+
+class surface_adsorption(cek.cek_labs):
+    def setup_lab(self):
+        """
+        Define base information for the lab.
+        They can be overwrite by the user using the kwargs in the constructor or
+        by calling the set_parameters method.
+        """
+        self.add_metadata( 
+            laboratory = 'Surface Adsorption Lab',
+            columns = ["Dye added (mg)", "Dye in solution (mol/L)"]
+            )
+        
+        self.volume = 1 # L
+        self.minDye = 500 # mg
+        self.maxDye = 10000 # mg
+        
+        self.sample_parameters = {
+            "dH"       : -19.51e3, # J/mol
+            "dS"       : -10, # J/mol/K
+            "Q"        : 0.0001, # monolayer coverage (mol/m^2)
+            "molarMass": 584.910641, # g/mol
+            }
+
+        self.number_of_values = 100 
+        self.noise_level = 1e-6
+        self.precision = 10
+
+    def create_data(self):
+        """
+        Generate the data
+        """
+        self.set_parameters( 
+            sample = self.sample,
+            number_of_values = self.number_of_values,
+            )
+
+        self.add_metadata(**{
+            "Temperature (K)"    : self.temperature,
+            "Volume (L)"         : self.volume,
+            "Molar mass (g/mol)" : self.sample_parameters["molarMass"],
+            "MinDye (mg)"        : self.minDye,
+            "MaxDye (mg)"        : self.maxDye,
+            'Number of values'   : self.number_of_values,
+        })
+
+        # Langmuir isotherm equilibrium constant
+        # Convert to kJ/mol
+        lnK = (-self.sample_parameters["dH"] / (self.temperature) + self.sample_parameters["dS"]) / self.R
+        K = np.exp(lnK) # in L/mol
+
+        conversion_factor = 1000 * self.sample_parameters["molarMass"] * self.volume
+        conc_range = np.array([self.minDye, self.maxDye]) / conversion_factor
+
+        self.data = self.generate_data_from_function(
+                lambda x,K,Q: ((x*K - K*Q - 1) + np.sqrt((x*K - K*Q - 1)**2 + 4*x*K) ) / (2*K) , 
+                {"K":K , "Q":self.sample_parameters["Q"]}, 
+                self.number_of_values,
+                xrange = conc_range, 
+                xspacing = 'linear',
+                noise_level = self.noise_level,
+                positive = True,
+                )
+            
+        self.data[:,0] *= conversion_factor
+        # grams of dye added
+        # x = np.linspace(self.minDye, self.maxDye, self.number_of_values) / 1000
+        # moles = x / self.params["molarMass"] # g
+        # initial_concentration = moles / self.volume # mol/L
+        # y = self.measure(K, self.params["Q"], initial_concentration)
+        
+        # # Because noise is added to the concentration in solution, but
+        # # the concentration on the surface is required in post-processing, which 
+        # # is very small, we divide by 1000
+
+        # y = cek.add_noise(y, self.uncertainty/1000)
+
+        # data_array = np.column_stack((x, y))
+
+        return self.data
+