fixes after lab 1

marimo/bomb_calorimetry.py

@@ -8,6 +8,7 @@ app = marimo.App(width="medium")
 def _():
     import marimo as mo
     import pycek_public as cek
+
     lab = cek.bomb_calorimetry(make_plots=True)
     return cek, lab, mo
 
@@ -41,24 +42,14 @@ def _(mo):
 @app.cell
 def _(lab, mo):
     def set_ID(value):
-        try:
-            student_number = int(value.strip())
-            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:
-            mo.stop(not student_ID.value.isdigit(), mo.md(f"### Invalid Student ID: {student_ID.value}"))
-            print(mo.md(f"### Invalid Student ID: {student_ID.value}"))
-
-    student_ID = mo.ui.text(value="", label="Student ID:",on_change=set_ID)
+        return cek.set_ID(mo, lab, 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)
+    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:"
@@ -99,7 +90,7 @@ def _(cek, lab, mo, reset_button, run_button, sample_selector):
 
         fname = lab.filename_gen.random
         message = f"### Running Experiment\n"
-        for k,v in lab.metadata.items():
+        for k, v in lab.metadata.items():
             message += f"####{k} = {v}\n"
         message += f"#### File created = {fname}\n"
 
@@ -110,9 +101,9 @@ def _(cek, lab, mo, reset_button, run_button, sample_selector):
         )
 
         plot = cek.plotting()
-        image = plot.quick_plot(scatter=data,output="marimo")
+        image = plot.quick_plot(scatter=data, output="marimo")
 
-    mo.hstack([mo.vstack([mo.md(message),download_button]),image])
+    mo.hstack([mo.vstack([mo.md(message), download_button]), image])
     return (
         data,
         download_button,
@@ -129,6 +120,7 @@ def _(cek, lab, mo, reset_button, run_button, sample_selector):
 @app.cell
 def _():
     import numpy as np
+
     return (np,)
 
 

marimo/crystal_violet.py

@@ -8,6 +8,7 @@ app = marimo.App(width="medium")
 def _():
     import marimo as mo
     import pycek_public as cek
+
     lab = cek.crystal_violet(make_plots=True)
     return cek, lab, mo
 
@@ -46,41 +47,44 @@ def _(mo):
 @app.cell
 def _(lab, mo):
     def set_ID(value):
-        try:
-            student_number = int(value.strip())
-            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:
-            mo.stop(not student_ID.value.isdigit(), mo.md(f"### Invalid Student ID: {student_ID.value}"))
-            print(mo.md(f"### Invalid Student ID: {student_ID.value}"))
-
-    student_ID = mo.ui.text(value="", label="Student ID:",on_change=set_ID)
+        return cek.set_ID(mo, lab, 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)")
+    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])
+    mo.vstack(
+        [
+            student_ID,
+            exp_ID,
+            cv_volume,
+            oh_volume,
+            h2o_volume,
+            temperature,
+            run_button,
+            reset_button,
+        ]
+    )
     return (
         cv_volume,
         exp_ID,
@@ -120,15 +124,15 @@ def _(
         h2o_vol = h2o_volume.value
 
         lab.set_parameters(
-            volumes={'cv': cv_vol, 'oh': oh_vol, 'h2o': h2o_vol},
-            temperature=temperature.value+273.15
+            volumes={"cv": cv_vol, "oh": oh_vol, "h2o": h2o_vol},
+            temperature=temperature.value + 273.15,
         )
         data = lab.create_data()
         file_content = lab.write_data_to_string()
 
         fname = lab.filename_gen.random
         message = f"### Running Experiment\n"
-        for k,v in lab.metadata.items():
+        for k, v in lab.metadata.items():
             message += f"####{k} = {v}\n"
         message += f"#### File created = {fname}\n"
 
@@ -139,9 +143,9 @@ def _(
         )
 
         plot = cek.plotting()
-        image = plot.quick_plot(scatter=data,output="marimo")
+        image = plot.quick_plot(scatter=data, output="marimo")
 
-    mo.hstack([mo.vstack([mo.md(message),download_button]),image])
+    mo.hstack([mo.vstack([mo.md(message), download_button]), image])
     return (
         cv_vol,
         data,

marimo/statistics_lab.py

@@ -1,6 +1,6 @@
 import marimo
 
-__generated_with = "0.11.0"
+__generated_with = "0.11.9"
 app = marimo.App(width="medium")
 
 
@@ -8,6 +8,7 @@ app = marimo.App(width="medium")
 def _():
     import marimo as mo
     import pycek_public as cek
+
     lab = cek.stats_lab(make_plots=True)
     return cek, lab, mo
 
@@ -44,24 +45,14 @@ def _(mo):
 @app.cell
 def _(lab, mo):
     def set_ID(value):
-        try:
-            student_number = int(value.strip())
-            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:
-            mo.stop(not student_ID.value.isdigit(), mo.md(f"### Invalid Student ID: {student_ID.value}"))
-            print(mo.md(f"### Invalid Student ID: {student_ID.value}"))
-
-    student_ID = mo.ui.text(value="", label="Student ID:",on_change=set_ID)
+        return cek.set_ID(mo, lab, value)
+
+    student_ID = mo.ui.text(value="", label="Student ID:", on_change=set_ID)
 
     def set_fname(value):
-        lab._set_filename(value)
+        lab.output_file = value
 
-    exp_ID = mo.ui.text(value="Automatic", label="Output file:", 
-                        on_change=set_fname)
+    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:"
@@ -85,27 +76,35 @@ def _(lab, mo):
 
 
 @app.cell
-def _(cek, lab, mo, reset_button, run_button, sample_selector):
+def _(cek, lab, mo, reset_button, run_button, sample_selector, student_ID):
     if reset_button.value:
         lab.ID = 0
-        lab._set_filename(None)
+        lab.output_file = None
 
     image = ""
     message = ""
     download_button = ""
+    data = None
+    file_content = None
+    fname = None
+    plot = None
+    # print(run_button.value)
     if run_button.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
+        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("### No sample selected !!"))
+
+        lab.set_parameters(number_of_values=12, sample=sample_selector.value)
         data = lab.create_data()
         file_content = lab.write_data_to_string()
 
-        fname = lab.filename_gen.random
-        message = f"### Running Experiment\n"
-        for k,v in lab.metadata.items():
+        fname = lab.output_file
+        if not fname:
+            fname = lab.filename_gen.random
+        message = "### Running Experiment\n"
+        for k, v in lab.metadata.items():
             message += f"####{k} = {v}\n"
         message += f"#### File created = {fname}\n"
 
@@ -116,13 +115,11 @@ def _(cek, lab, mo, reset_button, run_button, sample_selector):
         )
 
         plot = cek.plotting()
-        image = plot.quick_plot(scatter=data,output="marimo")
-
-    mo.hstack([mo.vstack([mo.md(message),download_button]),image])
+        image = plot.quick_plot(scatter=data, output="marimo")
+    mo.hstack([mo.vstack([mo.md(message), download_button]), image])
     return (
         data,
         download_button,
-        f,
         file_content,
         fname,
         image,
@@ -133,5 +130,10 @@ def _(cek, lab, mo, reset_button, run_button, sample_selector):
     )
 
 
+@app.cell
+def _():
+    return
+
+
 if __name__ == "__main__":
     app.run()

marimo/surface_adsorption.py

@@ -8,6 +8,7 @@ app = marimo.App(width="medium")
 def _():
     import marimo as mo
     import pycek_public as cek
+
     lab = cek.cek.surface_adsorption(make_plots=True)
     return cek, lab, mo
 
@@ -43,36 +44,25 @@ def _(mo):
 @app.cell
 def _(lab, mo):
     def set_ID(value):
-        try:
-            student_number = int(value.strip())
-            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:
-            mo.stop(not student_ID.value.isdigit(), mo.md(f"### Invalid Student ID: {student_ID.value}"))
-            print(mo.md(f"### Invalid Student ID: {student_ID.value}"))
-
+        return cek.set_ID(mo, lab, value)
 
-    student_ID = mo.ui.text(value="", label="Student ID:",on_change=set_ID)
+    student_ID = mo.ui.text(value="", label="Student ID:", on_change=set_ID)
 
     def set_fname(value):
-        lab._set_filename(value)
+        lab.output_file = 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)")
+    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])
+    mo.vstack([student_ID, exp_ID, temperature, run_button, reset_button])
     return (
         exp_ID,
         reset_button,
@@ -88,45 +78,41 @@ def _(lab, mo):
 def _(cek, lab, mo, reset_button, run_button, student_ID, temperature):
     if reset_button.value:
         lab.ID = 0
-        lab._set_filename(None)
+        lab.output_file = None
 
     image = ""
     message = ""
     download_button = ""
-    if run_button.value:
-        lab.set_parameters(
-            temperature = temperature.value+273.15
-        )
-        data = lab.create_data()
-        file_content = lab.write_data_to_string()
-    
-        fname = lab.filename_gen.random
-        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()
-        image = plot.quick_plot(scatter=data,output="marimo")
-    
-    mo.hstack([mo.vstack([mo.md(message),download_button]),image])
+    if not run_button.value:
+        return
+    lab.set_parameters(temperature=temperature.value + 273.15)
+    data = lab.create_data()
+    file_content = lab.write_data_to_string()
+
+    fname = lab.filename_gen.random
+    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()
+    image = plot.quick_plot(scatter=data, output="marimo")
+
+    mo.hstack([mo.vstack([mo.md(message), download_button]), image])
     return (
         data,
         download_button,
-        f,
         file_content,
         fname,
         image,
-        k,
         message,
         plot,
-        v,
     )
 
 

pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "setuptools.build_meta"
 where = ["src"]
 
 [project]
-name = "pycek"
+name = "pycek_public"
 version = "1.0.0"
 requires-python = ">= 3.8"
 authors = [
@@ -18,8 +18,11 @@ readme = {file = "README.md", content-type = "text/markdown"}
 dependencies = [
     "numpy",
     "scipy",
+    "lmfit",
     "colorama",
     "matplotlib",
+    "marimo",
+    "fastapi"
 ]
 
 [project.optional-dependencies]

src/pycek_public/cek_labs.py

@@ -1,18 +1,20 @@
-import pycek_public as cek
+import pycek as cek
 import numpy as np
 from typing import Callable, Dict, Optional, Union, Tuple
 
 from collections import OrderedDict
 
 from abc import ABC, abstractmethod
+
+
 class cek_labs(ABC):
-    def __init__(self, **kwargs):        
+    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
@@ -25,18 +27,20 @@ class cek_labs(ABC):
         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.metadata = OrderedDict(
+            {
+                "student_ID": self.student_ID,
+                "number_of_values": self.number_of_values,
+                "output_file": self.output_file,
+            }
+        )
+
         self.make_plots = False
         self.logger_level = "ERROR"
 
         # Define some lab specific parameters
         # Can overwrite the defaults
-        for k,w in kwargs.items():
+        for k, w in kwargs.items():
             setattr(self, k, w)
         np.random.seed(self.student_ID)
 
@@ -56,12 +60,12 @@ class cek_labs(ABC):
         self.list_of_data_files = []
 
     def __str__(self):
-        return f'CHEM2000 Lab: {self.__class__.__name__}'
+        return f"CHEM2000 Lab: {self.__class__.__name__}"
 
-    def set_student_ID(self,student_ID):
-        if isinstance(student_ID,int):
+    def set_student_ID(self, student_ID):
+        if isinstance(student_ID, int):
             self.student_ID = student_ID
-        elif isinstance(student_ID,str):
+        elif isinstance(student_ID, str):
             student_ID = student_ID.strip()
             if student_ID.isdigit():
                 self.student_ID = int(student_ID)
@@ -78,7 +82,7 @@ class cek_labs(ABC):
 
     def set_token(self, token):
         self.token = token
-        #print(f"Check: {self._check_token()}")
+        # print(f"Check: {self._check_token()}")
 
     def _check_token(self):
         if self.token != 23745419:
@@ -89,7 +93,7 @@ class cek_labs(ABC):
         for key, value in kwargs.items():
             self.metadata[key] = value
         return
-    
+
     def update_metadata_from_attr(self):
         for k in self.metadata:
             try:
@@ -97,12 +101,12 @@ class cek_labs(ABC):
             except:
                 pass
         return
-    
+
     def set_parameters(self, **kwargs):
         """
         Set parameters for the lab
         """
-        for k,w in kwargs.items():
+        for k, w in kwargs.items():
             if k == "student_ID":
                 self.set_student_ID(w)
             else:
@@ -110,53 +114,55 @@ class cek_labs(ABC):
         self.update_metadata_from_attr()
         return
 
-    def write_metadata(self,f=None):
+    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:
+                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.replace("_", " ")
             string = string[0].upper() + string[1:] + f" = {value}"
             dump(string)
 
-    def read_metadata(self,f):
+    def read_metadata(self, f):
         """
         Read metadata from the data file
-        
+
         Return: metadata (dict)
         """
         metadata = OrderedDict({})
 
         hash_lines = []
-        with open(f, 'r') as file:
+        with open(f, "r") as file:
             for line in file:
-                if line.strip().startswith('#'):
-                    hash_lines.append(line.replace('#','').strip())
-        
+                if line.strip().startswith("#"):
+                    hash_lines.append(line.replace("#", "").strip())
+
         for l in hash_lines:
             if ":" in l:
-                key, value = l.split(':')
+                key, value = l.split(":")
             elif "=" in l:
-                key, value = l.split('=')
+                key, value = l.split("=")
             else:
                 raise Exception("Unknown separator")
-            key = key.replace("#","").strip()
+            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:
@@ -164,14 +170,14 @@ class cek_labs(ABC):
         self.add_metadata(output_file=filename)
 
         string = self.write_data_to_string(**kwargs)
-        with open(filename, 'w') as f:
+        with open(filename, "w") as f:
             f.write(string)
 
-        self.list_of_data_files.append( filename )
+        self.list_of_data_files.append(filename)
 
         return filename
 
-    def write_data_to_string(self,**kwargs):
+    def write_data_to_string(self, **kwargs):
         if "columns" in kwargs:
             string = ",".join(kwargs["columns"]) + "\n"
         elif "columns" in self.metadata:
@@ -183,21 +189,21 @@ class cek_labs(ABC):
         for row in self.data:
             # Handle multiple columns
             if isinstance(row, (list, tuple, np.ndarray)):
-                string += ",".join(map(str, row))+"\n"
+                string += ",".join(map(str, row)) + "\n"
             # Handle single-column case
             else:
-                string += str(row)+"\n"
+                string += str(row) + "\n"
 
         # Write metadata
         for key, value in self.metadata.items():
             s = f"{key}"
-            s = s.replace("_"," ")
+            s = s.replace("_", " ")
             s = s[0].upper() + s[1:] + f" = {value}"
             string += f"# {s}\n"
 
         return string
 
-    def read_data_file(self,filename=None):
+    def read_data_file(self, filename=None):
         if filename is None:
             raise ValueError("Filename is missing")
 
@@ -221,10 +227,14 @@ class cek_labs(ABC):
         from numpy.lib.recfunctions import structured_to_unstructured
 
         data = np.genfromtxt(
-            StringIO(data_lines), delimiter=',', 
-            comments='#', names=True, 
-            skip_header=0, dtype=None)   
-        
+            StringIO(data_lines),
+            delimiter=",",
+            comments="#",
+            names=True,
+            skip_header=0,
+            dtype=None,
+        )
+
         data_array = structured_to_unstructured(data)
 
         metadata = None
@@ -232,27 +242,28 @@ class cek_labs(ABC):
             metadata = OrderedDict({})
             for l in comments:
                 if ":" in l:
-                    key, value = l.split(':')
+                    key, value = l.split(":")
                 elif "=" in l:
-                    key, value = l.split('=')
+                    key, value = l.split("=")
                 else:
                     raise Exception("Unknown separator")
-                key = key.replace("#","").strip()
+                key = key.replace("#", "").strip()
                 metadata[key.strip()] = value.strip()
 
-        self.logger.debug("-"*50)
-        for k,v in metadata.items():
+        self.logger.debug("-" * 50)
+        for k, v in metadata.items():
             self.logger.debug(f"{k} = {v}")
-        self.logger.debug("-"*50)
+        self.logger.debug("-" * 50)
         # Output results
         # print("Comments:")
         # print("\n".join(comments))
         # print("\nExtracted Data:")
         # print(data_array)
         return data_array, header, metadata
-    
+
     def _cleanup(self, pattern=None):
         from pathlib import Path
+
         for ff in self.list_of_data_files:
             # Check if file exists before deleting
             file_path = Path(ff)
@@ -263,19 +274,19 @@ class cek_labs(ABC):
 
         # Delete multiple files using a pattern
         if pattern is not None:
-            for file_path in Path('.').glob(pattern):
+            for file_path in Path(".").glob(pattern):
                 file_path.unlink()
 
     # def process_file(self, filename=None):
     #     self.read_data(filename)
     #     result = self.process_data()
     #     return result
-    
-    def _valid_ID(self,ID):
+
+    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
@@ -287,14 +298,16 @@ class cek_labs(ABC):
             else:
                 precision = int(-np.log10(precision))
         elif not isinstance(precision, (int, type(None))):
-            raise TypeError(f"Precision must be an integer or float, got {type(precision)}")
+            raise TypeError(
+                f"Precision must be an integer or float, got {type(precision)}"
+            )
 
         return np.round(values, decimals=precision)
-    
+
     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):
+    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)
@@ -303,9 +316,9 @@ class cek_labs(ABC):
         if len(prm) == 1:
             return np.array(self._round_values(values))
         else:
-            return np.column_stack( [*list_of_1d_arrays] )
+            return np.column_stack([*list_of_1d_arrays])
 
-    def _generate_noise(self,n,noise_level=None,ntype="normal"):
+    def _generate_noise(self, n, noise_level=None, ntype="normal"):
         if noise_level == None:
             raise ValueError("Missing noise level")
         if noise_level <= 0:
@@ -314,10 +327,10 @@ class cek_labs(ABC):
             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))
+        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))
+        return np.column_stack((x, y))
 
     def generate_data_from_function(
         self,
@@ -325,11 +338,11 @@ class cek_labs(ABC):
         params: Dict,
         nvalues: int,
         xrange: Optional[Tuple[float, float]] = None,
-        xspacing: str = 'random',
+        xspacing: str = "random",
         noise_level: Optional[float] = None,
         background: Optional[float] = None,
         weights: Optional[bool] = None,
-        positive: bool = False
+        positive: bool = False,
     ) -> np.ndarray:
         """
         Generate synthetic data points from a given function with optional noise and background.
@@ -370,7 +383,7 @@ class cek_labs(ABC):
         # 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")
 
@@ -388,13 +401,13 @@ class cek_labs(ABC):
         # Add optional modifications
         if background is not None:
             y += background
-        
+
         if noise_level is not None:
-            y += self._generate_noise(nvalues,noise_level)
-        
+            y += self._generate_noise(nvalues, noise_level)
+
         if positive:
-            eps = np.power(10.,-self.precision)
-            y = [ max(eps,np.abs(x)) for x in y ]
+            eps = np.power(10.0, -self.precision)
+            y = [max(eps, np.abs(x)) for x in y]
 
         # Note: weights parameter is currently unused
         if weights is not None:
@@ -407,21 +420,44 @@ class cek_labs(ABC):
 
     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']
-    
+        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):
+    def setup_lab(self, **kwargs):
         pass
 
     @abstractmethod
     def create_data(self):
         pass
 
+    ## --- END STUDENT VERSION -- ##
+
+    def process_data_file(self, filename):
+        self.logger.result(f"Processing file {filename}")
+        data, cols, mtd = self.read_data_file(filename)
+        result = self.process_data(data, mtd)
+        return result
+
+    @abstractmethod
+    def process_data(self, data, **kwargs):
+        pass
+
+
+def set_ID(mo, lab, value):
+    try:
+        student_number = int(value.strip())
+        if student_number <= 0:
+            error = f"### Invalid Student ID: {value}"
+            print(mo.md(error))
+            raise ValueError(error)
+        print(mo.md(f"Valid Student ID: {student_number}"))
+        lab.set_student_ID(int(value))
+    except ValueError:
+        print(mo.md(f"### Invalid Student ID: {value}"))

src/pycek_public/plotting.py

@@ -53,6 +53,11 @@ class plotting():
         # Display the legend
         plt.legend()
 
+        ax = plt.gca()
+        ax.text(0.5, 0.5, 'TEMPLATE', transform=ax.transAxes,
+            fontsize=40, color='gray', alpha=0.5,
+            ha='center', va='center', rotation=30)
+
         # Show the plot
         if output is None:
             plt.show()
@@ -62,3 +67,169 @@ class plotting():
             plt.savefig(output)
         plt.close()
 
+    ## --- END STUDENT VERSION -- ##
+
+    def get_t_value(self, ndof, confidence=None):
+        """
+        Calculate the two-tailed Student's t-value for a given number of degrees of freedom
+        and confidence level.
+
+        Parameters:
+            ndof (int): Number of degrees of freedom
+            confidence (float): Confidence level, default is 0.95 for 95% confidence
+
+        Returns:
+            float: The critical t-value for the specified parameters
+
+        Example:
+            For 95% confidence and 10 degrees of freedom:
+            >>> get_t_value(10)
+            2.2281388519495335
+        """
+        if confidence is None:
+            confidence = self._confidence_level
+
+        # Calculate alpha (significance level) from confidence level
+        # For 95% confidence, alpha = 0.05
+        alpha = 1 - confidence
+
+        # Calculate the t-value using the percent point function (PPF) of the t-distribution
+        # We use alpha/2 for two-tailed test and (1 - alpha/2) for the upper tail
+        tval = stats.t.ppf(1.0 - alpha/2., ndof)
+
+        return tval
+
+    def plot_fit_with_confidence_band(
+        self, data, fit_model, popt, 
+        confidence=None, output=None):
+        """
+        Plot the data along with the best fit line and its associated confidence band.
+
+        Parameters:
+            x_data (array-like): Independent variable data points
+            y_data (array-like): Observed dependent variable values
+            fit_model (callable): The model function used in the fit
+            popt: Optimal parameter values from the fit
+            confidence (float, optional): Confidence level for the confidence band
+                                        (default is 0.95)
+
+        Returns:
+            None: Displays a matplotlib plot with data, fit line, and confidence band
+
+        Example:
+            >>> fit_result = scipy_function_fit(x_data, y_data, linear_model)
+            >>> plot_fit_with_confidence_band(x_data, y_data, fit_result)
+        """
+        x_data = data[:,0]
+        y_data = data[:,1]
+
+        # Calculate degrees of freedom: number of data points minus number of parameters
+        ndof = max(0, len(x_data) - len(popt))
+
+        # Create the plot figure with a specified size
+        plt.figure(figsize=(10, 6))
+
+        # Plot the observed data points as a scatter plot
+        plt.scatter(x_data, y_data, color='blue', label='Data')
+
+        # Generate points for the fitted line
+        # Linearly spaced between the minimum and maximum of x_data
+        x_fit = np.linspace(min(x_data), max(x_data), 100)
+
+        # Calculate the fitted y values using the optimal parameters
+        y_fit = fit_model(x_fit, *popt)
+
+        # Plot the fitted line
+        plt.plot(x_fit, y_fit, 'r-', label='Best fit')
+
+        if confidence is not None:
+            # Calculate the error for the confidence band based on the data and fit
+            y_err = np.sqrt(1/len(x_data) + (x_fit - np.mean(x_data))**2 /
+                            np.sum((x_data - np.mean(x_data))**2))
+
+            # t-statistic used to calculate the confidence interval
+            tval = self.get_t_value(ndof, confidence)
+
+            # Calculate the upper and lower bounds of the confidence band
+            bounds = np.sqrt(np.sum((y_data - fit_model(x_data, *popt))**2) / ndof)
+            y_upper = y_fit + tval * y_err * bounds
+            y_lower = y_fit - tval * y_err * bounds
+
+            # Plot the confidence band by shading the area between the upper and lower bounds
+            plt.fill_between(x_fit, y_lower, y_upper,
+                            color='gray', alpha=0.2,
+                            label=f'{int(confidence*100)}% Confidence band')
+            plt.title(f'Data with Linear Fit and {int(confidence*100)}% Confidence Bands')
+        else:
+            plt.title(f'Data with Linear Fit')
+
+        # Add labels and title to the plot
+        plt.xlabel('x')
+        plt.ylabel('y')
+    
+        # ymin = np.min(y_data) - 0.1*np.abs(np.min(y_data))
+        # ymax = np.max(y_data) + 0.1*np.abs(np.max(y_data))
+        # ax = plt.gca()        
+        # ax.set_ylim([ymin, ymax])
+
+        # Display the legend
+        plt.legend()
+
+        # Show the plot
+        if output is None:
+            plt.show()
+        else:
+            plt.savefig(output)
+
+    def plot_residuals(self, data, fit_model, popt):
+        """
+        Create a residual plot to visualize the differences between observed and predicted values.
+        Residuals are the differences between actual y values and model predictions.
+
+        Parameters:
+            x_data (array-like): Independent variable data points (input for the model)
+            y_data (array-like): Observed dependent variable values (true values)
+            fit_model (callable): The model function used in the fit
+            popt: Optimal parameter values from the fit
+                The 'result' dictionary should include at least the 'popt' key, which contains the
+                optimal parameters for the fitted model.
+
+        Returns:
+            None: Displays a matplotlib plot of residuals
+
+        Example:
+            >>> fit_result = scipy_function_fit(x_data, y_data, linear_model)
+            >>> plot_residuals(x_data, y_data, fit_result)
+        """
+        x_data = data[:,0]
+        y_data = data[:,1]
+
+        # Calculate model predictions using the fitted parameters ('popt' contains optimal parameters)
+        y_pred = fit_model(x_data, *popt)
+
+        # Calculate residuals (observed y values - predicted y values)
+        residuals = y_data - y_pred
+
+        # Create a new figure with a specified size for the plot
+        plt.figure(figsize=(10, 6))
+
+        # Scatter plot of the residuals vs the x_data points
+        # Each point in the scatter plot corresponds to the residual for a specific x_data value
+        plt.scatter(x_data, residuals, color='blue', label='Data')
+
+        # Add a horizontal line at y=0 for reference to see how residuals deviate from 0
+        plt.axhline(y=0, color='black', linestyle='--', label='Zero Residuals')
+
+        # Label the x and y axes
+        plt.xlabel('x')  # x-axis represents the independent variable
+        plt.ylabel('e')  # y-axis represents the residuals or errors (observed - predicted)
+
+        # Add a title to the plot
+        plt.title('Plot of the residuals')
+
+        # Optionally, add a legend to clarify the plot's labels
+        plt.legend()
+
+        # Display the plot
+        # plt.savefig("fit_residuals.png")
+        plt.show()