remove build directory...

Dockerfile

@@ -5,10 +5,12 @@ 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
-RUN uv pip install git+https://github.com/praiteri/pycek_public
-RUN uv pip install marimo fastapi colorama
+COPY --chown=user ./ /pycek_public
+RUN uv pip install /pycek_public && rm -rf /pycek_public
 COPY --chown=user ./marimo /app
 RUN chown -R user:user /app
 USER user

build/lib/pycek_public/__init__.py

@@ -1,10 +0,0 @@
-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

@@ -1,113 +0,0 @@
-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

@@ -1,388 +0,0 @@
-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

@@ -1,75 +0,0 @@
-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

@@ -1,166 +0,0 @@
-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

@@ -1,112 +0,0 @@
-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

@@ -1,125 +0,0 @@
-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

@@ -1,89 +0,0 @@
-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
-