sleeping now

Author: prathameshnium

Keithley_2400/Backends/IV_K2400_Loop_Backend_v10.py

@@ -22,7 +22,6 @@
 import numpy as np
 import matplotlib.pyplot as plt
 from time import sleep
-import pyvisa
 from pymeasure.instruments.keithley import Keithley2400
 import pandas as pd
 
@@ -90,8 +89,4 @@ def IV_Measure(cur):
     plt.title('I-V Curve')
     plt.legend()
     plt.grid(True)
-    plt.show()
-
-
-if __name__ == "__main__":
-    main()
+    plt.show()

Keithley_6517B/High_Resistance/Backends/IV_K6517B_Simple_Backend_v10.py

@@ -54,7 +54,6 @@ def get_sweep_parameters():
         filename += '.csv'
     return start_v, stop_v, steps, delay, filename
 
-
 def plot_results(data):
     """Plots the I-V curve from the collected data."""
     if not data:

Keithley_6517B/High_Resistance/IV_K6517B_GUI_v11.py

@@ -314,8 +314,10 @@ def setup_styles(self):
             focuscolor='none')
         style.map(
             'TButton',
-            background=[('active', self.CLR_ACCENT_GOLD), ('hover', self.CLR_ACCENT_GOLD)],
-            foreground=[('active', self.CLR_TEXT_DARK), ('hover', self.CLR_TEXT_DARK)]
+            background=[('active', self.CLR_ACCENT_GOLD),
+                        ('hover', self.CLR_ACCENT_GOLD)],
+            foreground=[('active', self.CLR_TEXT_DARK),
+                        ('hover', self.CLR_TEXT_DARK)]
         )
         style.configure(
             'Start.TButton',

Keithley_6517B/Pyroelectricity/Pyroelectric_K6517B_L350_GUI_v4.py

@@ -849,9 +849,9 @@ def _process_data_queue(self):
                 elif state == 'ramping':
                     elapsed_time = time.time() - self.start_time
                     log_msg = (
-                        f"Ramping... Time: {elapsed_time:7.1f}s | "
-                        f"Temp: {current_temp:8.4f}K | "
-                        f"Current: {current_val:.3e} A"
+                        f"Time: {elapsed_time:.1f}s | "
+                        f"Temp: {current_temp:.2f}K | "
+                        f"Current: {current_val:.2e}A"
                     )
                     self.log(log_msg)
 

PICA_v6.py

@@ -504,7 +504,6 @@ def _configure_scrollable_frame(event):
                 5, 10), pady=(
                 0, 15))
 
-
         # --- Left Column Suites ---
         self._create_suite_frame(left_col,
                                  'Low Resistance (10 nΩ to 100 MΩ)',

Utilities/LivePlotter_v10.py

@@ -69,7 +69,7 @@ def animate(i):
         axs[2].set_ylabel('Voltage (V)', fontsize=13)
         axs[2].legend(loc='upper left')
 
-    ani = FuncAnimation(plt.gcf(), animate, interval=1000, cache_frame_data=False)
+    ani = FuncAnimation(plt.gcf(), animate, interval=1000, cache_frame_data=False) # noqa: F841
 
     plt.tight_layout()
     plt.show()

Utilities/PlotterUtil_GUI_v3.py

@@ -954,96 +954,207 @@ def _finalize_plot(self, x_col, y_col, selected_filepaths):
         else:
             legend_title = "Multiple Files"
 
-        leg = self.ax_main.legend(title=legend_title, labelcolor=self.CLR_CONSOLE_BG)
-        if leg:
-            leg.get_title().set_color(self.CLR_CONSOLE_BG)
-
-        self.ax_main.set_xscale(
-            'log' if self.x_log_var.get() else 'linear')  # type: ignore
-        self.ax_main.set_yscale(
-            'log' if self.y_log_var.get() else 'linear')
-        self.ax_main.set_xlabel(x_col)
-        self.ax_main.set_ylabel(y_col)
-
-        if len(selected_filepaths) == 1:
-            self.ax_main.set_title(
-                os.path.basename(
-                    selected_filepaths[0]),
-                fontweight='bold')
-        else:
-            self.ax_main.set_title(
-                f"{y_col} vs. {x_col}",
-                fontweight='bold')
-        self.figure.tight_layout()
-
-    def _handle_load_error(self, filepath, e):
-        """Handles errors during file loading."""
-        if filepath in self.file_data_cache:
-            self.file_data_cache[filepath] = {
-                "path": filepath, "headers": [], "data": {}}
-        self.column_source_var.set("Columns from: (no file selected)")
-        self.active_filepath = None
-        self.plot_data()
-        self.x_col_cb.set('')
-        self.y_col_cb.set('')
-        self.x_col_cb['values'] = []
-        self.y_col_cb['values'] = []
-        self.live_update_var.set(False)
-        self.toggle_live_update()
-        self.log(f"Error loading file: {traceback.format_exc()}")
-        messagebox.showerror(
-            "File Load Error",
-            f"Could not read the data file. It may be empty, malformed, or in use.\n\nDetails: {e}")
-
-    def toggle_live_update(self):
-        if self.live_update_var.get():
-            self.start_file_watcher()
-        else:
-            self.stop_file_watcher()
-
-    def start_file_watcher(self):
-        self.stop_file_watcher()  # Ensure no multiple watchers are running
-        if self.live_update_var.get() and self.active_filepath:
-            self.log("Live update enabled. Watching for file changes...")
-            self.file_watcher_job = self.root.after(
-                1000, self.check_for_updates)
-
-    def stop_file_watcher(self):
-        if self.file_watcher_job:
-            self.root.after_cancel(self.file_watcher_job)
-            self.file_watcher_job = None
-            self.log("Live update disabled.")
-
-    def check_for_updates(self):
-        if not self.active_filepath or not self.live_update_var.get(
-        ) or not os.path.exists(self.active_filepath):
-            self.file_watcher_job = None  # Stop watching if file is gone or disabled
-            return
-
-        try:
-            file_info = self.file_data_cache[self.active_filepath]
-            mod_time = os.path.getmtime(self.active_filepath)
-            current_size = os.path.getsize(self.active_filepath)
-
-            if mod_time != file_info.get('mod_time'):
-                if current_size > file_info.get('size', 0):
-                    # File has grown, append new data
-                    self.append_file_data()
+                leg = self.ax_main.legend(title=legend_title,
+            
+                                          labelcolor=self.CLR_CONSOLE_BG)
+            
+                if leg:
+            
+                    leg.get_title().set_color(self.CLR_CONSOLE_BG)
+            
+        
+            
+                self.ax_main.set_xscale(
+            
+                    'log' if self.x_log_var.get() else 'linear')  # type: ignore
+            
+                self.ax_main.set_yscale(
+            
+                    'log' if self.y_log_var.get() else 'linear')
+            
+                self.ax_main.set_xlabel(x_col)
+            
+                self.ax_main.set_ylabel(y_col)
+            
+        
+            
+                if len(selected_filepaths) == 1:
+            
+                    self.ax_main.set_title(
+            
+                        os.path.basename(
+            
+                            selected_filepaths[0]),
+            
+                        fontweight='bold')
+            
+                else:
+            
+                    self.ax_main.set_title(
+            
+                        f"{y_col} vs. {x_col}",
+            
+                        fontweight='bold')
+            
+                self.figure.tight_layout()
+            
+        
+            
+            def _handle_load_error(self, filepath, e):
+            
+                """Handles errors during file loading."""
+            
+                if filepath in self.file_data_cache:
+            
+                    self.file_data_cache[filepath] = {
+            
+                        "path": filepath, "headers": [], "data": {}}
+            
+                self.column_source_var.set("Columns from: (no file selected)")
+            
+                self.active_filepath = None
+            
+                self.plot_data()
+            
+                self.x_col_cb.set('')
+            
+                self.y_col_cb.set('')
+            
+                self.x_col_cb['values'] = []
+            
+                self.y_col_cb['values'] = []
+            
+                self.live_update_var.set(False)
+            
+                self.toggle_live_update()
+            
+                self.log(f"Error loading file: {traceback.format_exc()}")
+            
+                messagebox.showerror(
+            
+                    "File Load Error",
+            
+                    f"Could not read the data file. It may be empty, malformed, or in use.\n\nDetails: {e}")
+            
+        
+            
+            def toggle_live_update(self):
+            
+                if self.live_update_var.get():
+            
+                    self.start_file_watcher()
+            
                 else:
-                    # File was overwritten or shrunk, do a full reload
+            
+                    self.stop_file_watcher()
+            
+        
+            
+            def start_file_watcher(self):
+            
+                self.stop_file_watcher()  # Ensure no multiple watchers are running
+            
+                if self.live_update_var.get() and self.active_filepath:
+            
+                    self.log("Live update enabled. Watching for file changes...")
+            
+                    self.file_watcher_job = self.root.after(
+            
+                        1000, self.check_for_updates)
+            
+        
+            
+            def stop_file_watcher(self):
+            
+                if self.file_watcher_job:
+            
+                    self.root.after_cancel(self.file_watcher_job)
+            
+                    self.file_watcher_job = None
+            
+                    self.log("Live update disabled.")
+            
+        
+            
+            def check_for_updates(self):
+            
+                if not self.active_filepath or not self.live_update_var.get(
+            
+                ) or not os.path.exists(self.active_filepath):
+            
+                    self.file_watcher_job = None  # Stop watching if file is gone or disabled
+            
+                    return
+            
+        
+            
+                try:
+            
+                    file_info = self.file_data_cache[self.active_filepath]
+            
+                    mod_time = os.path.getmtime(self.active_filepath)
+            
+                    current_size = os.path.getsize(self.active_filepath)
+            
+        
+            
+                    if mod_time != file_info.get('mod_time'):
+            
+                        if current_size > file_info.get('size', 0):
+            
+                            # File has grown, append new data
+            
+                            self.append_file_data()
+            
+                        else:
+            
+                            # File was overwritten or shrunk, do a full reload
+            
+                            self.log(
+            
+                                "File has been overwritten. Performing full reload...")
+            
+                            self.load_file_data(self.active_filepath)
+            
+                    else:
+            
+                        # If no changes, schedule the next check
+            
+                        self.file_watcher_job = self.root.after(
+            
+                            1000, self.check_for_updates)
+            
+        
+            
+                except OSError:
+            
+                    # File might have been deleted or is temporarily inaccessible
+            
                     self.log(
-                        "File has been overwritten. Performing full reload...")
-                    self.load_file_data(self.active_filepath)
-            else:
-                # If no changes, schedule the next check
-                self.file_watcher_job = self.root.after(
-                    1000, self.check_for_updates)
-
-        except OSError:
-            # File might have been deleted or is temporarily inaccessible
-            self.log(
-                "File watcher stopped: file is inaccessible or has been deleted.")
-            self.stop_file_watcher()
+            
+                        "File watcher stopped: file is inaccessible or has been deleted.")
+            
+                    self.stop_file_watcher()
+            
+        
+            
+        
+            
+        if __name__ == '__main__':
+            
+            # This is ESSENTIAL for multiprocessing to work in a bundled executable
+            
+            # and to prevent pickling errors with 'spawn' start method on Windows.
+            
+            multiprocessing.freeze_support()
+            
+        
+            
+            root = tk.Tk()
+            
+            app = PlotterApp(root)
+            
+            root.mainloop()
 
 
 if __name__ == '__main__':

deployment/Picachu.py

@@ -133,10 +133,12 @@ class PICALauncherApp:
     SCRIPT_PATHS = {
         "Sweep Mode I-V": os.path.join(SUB_PROGRAMS_DIR, "IV_K6221_DC_Sweep_GUI_V10.exe"),
         "Delta Mode R-T": os.path.join(SUB_PROGRAMS_DIR, "Delta_RT_K6221_K2182_L350_T_Control_GUI_v5.exe"),
-        "Delta Mode R-T (T_Sensing)": os.path.join(SUB_PROGRAMS_DIR, "Delta_RT_K6221_K2182_L350_Sensing_GUI_v5.exe"),
+        "Delta Mode R-T (T_Sensing)": os.path.join(
+            SUB_PROGRAMS_DIR, "Delta_RT_K6221_K2182_L350_Sensing_GUI_v5.exe"),
         "K2400 I-V": os.path.join(SUB_PROGRAMS_DIR, "IV_K2400_GUI_v5.exe"),
         "K2400 R-T": os.path.join(SUB_PROGRAMS_DIR, "RT_K2400_L350_T_Control_GUI_v3.exe"),
-        "K2400 R-T (T_Sensing)": os.path.join(SUB_PROGRAMS_DIR, "RT_K2400_L350_T_Sensing_GUI_v4.exe"),
+        "K2400 R-T (T_Sensing)": os.path.join(
+            SUB_PROGRAMS_DIR, "RT_K2400_L350_T_Sensing_GUI_v4.exe"),
         "K2400_2182 I-V": os.path.join(SUB_PROGRAMS_DIR, "IV_K2400_K2182_GUI_v3.exe"),
         "K2400_2182 R-T": os.path.join(SUB_PROGRAMS_DIR, "RT_K2400_K2182_T_Control_GUI_v3.exe"),
         "K2400_2182 R-T (T_Sensing)": os.path.join(SUB_PROGRAMS_DIR, "RT_K2400_2182_L350_T_Sensing_GUI_v2.exe"),
@@ -1151,6 +1153,6 @@ def main():
     # and ensures a consistent, stable process creation method across platforms.
     # 'spawn' is the most robust method for GUI apps, though it is the default
     # on Windows and macOS.
-    multiprocessing.set_start_method('spawn', force=True)
-    multiprocessing.freeze_support()
-    main()
+        multiprocessing.set_start_method('spawn', force=True)
+        multiprocessing.freeze_support()
+        main()