PaIRS-UniNa 0.1.13__cp310-cp310-win_amd64.whl → 0.2.8__cp310-cp310-win_amd64.whl

PaIRS_UniNa/Process_Tab_Min.py

@@ -0,0 +1,120 @@
+from .ui_Process_Tab_Min import*
+from .TabTools import*
+
+LaserTypeSearch_items=[ 'single laser', #0
+                        'double laser', #1
+                        ]
+LaserTypeSearch_order=[i for i in range(len(LaserTypeSearch_items))] #************ change here, please!
+
+spin_tips={
+    'SogliaNoise'       :   'Minimum allowed value for validation',
+    'SogliaStd'         :   'Minimum allowed st.d. value for validation',
+}
+check_tips={}
+radio_tips={
+    'TR': 'Time-resolved sequence',    
+}
+line_edit_tips={}
+button_tips={}
+combo_tips={
+    'LaserType': 'Laser setup',
+}
+
+class PROpar_Min(TABpar):
+    def __init__(self,Process=ProcessTypes.null,Step=StepTypes.null):
+        self.setup(Process,Step)
+        super().__init__('PROpar_Min','Process_Min')
+        self.unchecked_fields+=[]
+
+    def setup(self,Process,Step):
+        self.Process        = Process
+        self.Step           = Step
+
+        self.FlagTR      = False
+        self.LaserType   = 0   #0 single, 1 double
+        self.SogliaNoise = 5.0
+        self.SogliaStd   = 1.5
+
+class Process_Tab_Min(gPaIRS_Tab):
+    class Process_Tab_Signals(gPaIRS_Tab.Tab_Signals):
+        pass
+
+    def __init__(self,parent: QWidget =None, flagInit= __name__ == "__main__"):
+        super().__init__(parent,Ui_ProcessTab_Min,PROpar_Min)
+        self.signals=self.Process_Tab_Signals(self)
+    
+        #------------------------------------- Graphical interface: widgets
+        self.TABname='Process_Min'
+        self.ui: Ui_ProcessTab_Min
+
+        #necessary to change the name and the order of the items
+        for g in list(globals()):
+            if '_items' in g or '_ord' in g or '_tips' in g:
+                #pri.Info.blue(f'Adding {g} to {self.name_tab}')
+                setattr(self,g,eval(g))
+        
+        if __name__ == "__main__": 
+            self.app=app
+            setAppGuiPalette(self)
+
+        self.pixmap_laser_NTR=QPixmap(icons_path+'laser_NTR.png')
+        self.pixmap_laser_TR_single=QPixmap(icons_path+'laser_TR_single.png')
+        self.pixmap_laser_TR_double=QPixmap(icons_path+'laser_TR_double.png')    
+
+        #------------------------------------- Declaration of parameters 
+        self.PROpar_base=PROpar_Min()
+        self.PROpar:PROpar_Min=self.TABpar
+        self.PROpar_old:PROpar_Min=self.TABpar_old
+
+        #------------------------------------- Callbacks 
+        self.defineWidgets()
+        self.setupWid()  #---------------- IMPORTANT
+
+        self.defineCallbacks()
+        self.connectCallbacks()
+
+        self.defineSettings()
+        
+        self.adjustTABpar=self.adjustPROpar
+        self.setTABlayout=self.setPROlayout
+
+        #------------------------------------- Initializing    
+        if flagInit:     
+            self.initialize()
+
+
+    def initialize(self):
+        pri.Info.yellow(f'{"*"*20}   PROCESS Min initialization   {"*"*20}')
+        self.setTABpar(FlagAdjustPar=True,FlagBridge=False)
+        self.add_TABpar('initialization')
+        self.setFocus()
+
+#*************************************************** Adjusting parameters
+    def adjustPROpar(self):
+        if not self.PROpar.FlagTR: self.PROpar.LaserType=1
+        
+        
+#*************************************************** Layout
+    def setPROlayout(self):
+        #pri.Time.blue(1,'setPROpar: Beginning')
+        self.ui.w_LaserType.setEnabled(self.PROpar.FlagTR)
+
+        if not self.PROpar.FlagTR:
+            self.ui.example_label.setPixmap(self.pixmap_laser_NTR)
+        else:
+            if self.PROpar.LaserType==0:
+                self.ui.example_label.setPixmap(self.pixmap_laser_TR_single)
+            elif self.PROpar.LaserType==1:
+                self.ui.example_label.setPixmap(self.pixmap_laser_TR_double)
+
+
+if __name__ == "__main__":
+    import sys
+    app=QApplication.instance()
+    if not app:app = QApplication(sys.argv)
+    app.setStyle('Fusion')
+    object = Process_Tab_Min(None)
+    object.show()
+    app.exec()
+    app.quit()
+    app=None

PaIRS_UniNa/Saving_tools.py

@@ -0,0 +1,296 @@
+FLAG_SERIALIZED=True
+
+import os, json, pickle, traceback
+from .PaIRS_pypacks import pri
+
+from .TabTools import TABpar
+from .procTools import dataTreePar, CompMin, MediaPIV
+from .Explorer import TREpar, ITEpar, currentTimeString
+from .Input_Tab import INPpar
+globals()['ImportPar'] = INPpar.ImportPar
+from .Input_Tab_tools import ImageSet
+from .Output_Tab import OUTpar
+from .Process_Tab import PROpar
+from .Log_Tab import LOGpar
+from .Vis_Tab import VISpar, NamesPIV
+globals()['OUT'] = VISpar.OUT
+globals()['PRO'] = VISpar.PRO
+from .Process_Tab_Min import PROpar_Min
+from .Process_Tab_Disp import PROpar_Disp
+from .Calibration_Tab import CALpar
+from .Input_Tab_CalVi import INPpar_CalVi
+from .Process_Tab_CalVi import PROpar_CalVi
+from .Vis_Tab_CalVi import VISpar_CalVi
+from .tabSplitter import SPLpar
+from .PaIRS_pypacks import identifierName, fontPixelSize, printTypes
+from .__init__ import __version__,__subversion__,__year__,__mail__,__website__
+
+class GPApar(TABpar):
+    def __init__(self):
+        self.setup()
+        super().__init__(self.name,'gPaIRS')
+        self.unchecked_fields+=[]
+
+    def setup(self):
+        self.name_work, self.username, self.version = identifierName(typeObject='wksp')
+        self.outName   = ''
+        self.createdDate    = currentTimeString()
+        self.modifiedDate   = self.createdDate
+        self.savedDate      = ''
+        self.FlagSaved      = False
+        self.FlagQueue      = True
+        self.FlagRunnable   = True
+
+        self.name = 'Workspace'
+        self.date = f'Created: {self.createdDate}'
+        self.icon = 'workspace.png'
+
+        self.infoFields=[f for f,_ in self.__dict__.items()]
+
+        self.Geometry           = None
+        self.WindowState        = None
+        self.SplitterSizes      = {}
+        self.ScrollAreaValues   = {}
+
+        #legacy
+        self.FloatGeometry      = []
+        self.FloatVisible       = []
+
+        self.paletteType        = 2   #-1,2=standard, 0=light, 1=dark
+        self.fontPixelSize      = fontPixelSize
+        self.FlagOutDated       = 0
+        self.currentVersion     = __version__
+        self.latestVersion      = ''
+
+        self.printTypes         = printTypes
+        self.NumCores           = 0
+
+        self.stateFields=[f for f,_ in self.__dict__.items() if f not in self.infoFields]
+
+    def saveBullet(self):
+        return '' if self.FlagSaved else '<span style="color: #7A8B8B;"><sup>&#9679;</sup></span>'
+
+    def InfoMessage(self):
+        InfoMessage=f'{self.name}'
+        if self.FlagSaved:
+            InfoMessage+=f'\nFile location: {self.outName}'
+        else:
+            if self.savedDate: 
+                InfoMessage+=' (unsaved)'
+            else:
+                InfoMessage+=' (never saved)'
+        InfoMessage+=f'\n\nCreated : {self.createdDate}'
+        InfoMessage+=f'\nModified: {self.modifiedDate}'
+        if self.savedDate: InfoMessage+=f'\nSaved   : {self.savedDate}'
+        InfoMessage+=f'\n\nUser: {self.username}'
+        InfoMessage+=f'\nPaIRS version: {self.version}'
+        return InfoMessage
+ 
+def save_list_to_file_serialized(l, filename, flagJSON=False):
+    basename = os.path.splitext(filename)[0]
+    pickle_data = {}
+    pickle_counter = 0
+    info_pickle =[]
+
+    def serialize_element(elem:TABpar, idx_path):
+        nonlocal pickle_counter
+        if elem is None:
+            return None
+        data = {}
+        for field in elem.fields:
+            value = getattr(elem, field)
+            if isinstance(value, TABpar):
+                data[field] = serialize_element(value, idx_path + [field])
+            elif isinstance(value, CompMin) or isinstance(value, MediaPIV):
+                data[field] = {'__file_ref__': value.outName,
+                               'varClass':  value.__class__.__name__}
+                if isinstance(value, MediaPIV):
+                    data[field]['stepType']=value.stepType
+                try:
+                    if value.outName:
+                        with open(value.outName, 'wb') as file:
+                            pickle.dump(value, file)
+                except Exception as e:
+                    print(f'Error while saving the file {filename}!\n{e}\n')
+            elif is_non_json_serializable(value):
+                info=f'Element: {elem.__class__.__name__} --> field: {field} --> value type: {type(value)}'
+                info_pickle.append(info)
+                key = f"ref_{pickle_counter}"
+                pickle_data[key] = value
+                data[field] = {'__file_ref__': key}
+                pickle_counter += 1
+            else:
+                data[field] = value
+        data['parClass'] = elem.__class__.__name__
+        return data
+    
+    def serialize_list(lst, idx_path=[]):
+        if isinstance(lst, list):
+            return [serialize_list(item, idx_path + [i]) for i, item in enumerate(lst)]
+        else:
+            return serialize_element(lst, idx_path)
+    
+    serialized_list = serialize_list(l)
+    
+    try:
+        if flagJSON:
+            with open(filename, 'w') as file:
+                json.dump(serialized_list, file, indent=2)
+        else:
+            with open(filename, 'wb') as file:
+                pickle.dump(serialized_list, file)
+    except Exception as e:
+        print(f'Error while saving the file {filename}!\n{e}\n')
+        
+    if pickle_counter:
+        pri.IOError.yellow(f'The following non-json serializable items were found in {filename}:\n'+"\n".join(info_pickle))
+        pickle_filename = basename+'.pairs_data'
+        try:
+            with open(pickle_filename, 'wb') as file:
+                pickle.dump(pickle_data, file)
+        except Exception as e:
+            print(f'Error while saving the file {pickle_filename}!\n{e}\n')
+
+
+def load_list_from_file_serialized(filename):
+    basename = os.path.basename(filename)
+    pickle_filename =  basename+'.pairs_data'
+    
+    serialized_list=None
+    error=''
+    try:
+        with open(filename, 'rb') as file:
+            first_byte = file.read(1)
+            if first_byte in [b'{', b'[']:
+                file.seek(0)
+                try:
+                    serialized_list=json.load(file)
+                except Exception as e:
+                    error=e
+            else:
+                file.seek(0)
+                try:
+                    import numpy 
+                    serialized_list=pickle.load(file)
+                except Exception as e:
+                    error=e
+    except Exception as e:
+        error=e
+    if error:
+        pri.IOError.red(f'Error while loading the file {filename}!\n{error}\n')
+        return serialized_list, str(error)
+    
+    error=''
+    pickle_data = None
+    if os.path.exists(pickle_filename):
+        try:
+            with open(pickle_filename, 'rb') as file:
+                pickle_data = pickle.load(file)
+        except Exception as e:
+            pri.IOError.red(f'Error while loading the file {pickle_filename}!\n{e}\n')
+            error+=str(e)
+
+    info_pickle=[]
+
+    def deserialize_element(data):
+        if data is None:
+            return None  
+        try:  
+            cls_name = data.pop('parClass')
+        except:
+            pass
+        cls = globals()[cls_name]
+        if cls_name=='dataTreePar':
+            pass
+        instance:TABpar = cls()
+        fields  = {}
+        for key, value in data.items():
+            if isinstance(value, dict) and 'parClass' in value:
+                fields[key] = deserialize_element(value)
+            elif isinstance(value, dict) and 'varClass' in value:
+                filename =  value['__file_ref__']
+                field_cls_name = value['varClass']
+                field_cls = globals()[field_cls_name]
+                if field_cls==MediaPIV:
+                    new_instance:MediaPIV=field_cls(value['stepType'])
+                else:
+                    new_instance:CompMin=field_cls()
+                if filename:
+                    try:
+                        if os.path.exists(filename):
+                            with open(filename, 'rb') as file:
+                                loaded_instance:CompMin=pickle.load(file)
+                            for f in loaded_instance.fields:
+                                v_loaded=getattr(loaded_instance,f)
+                                if isinstance(v_loaded,TABpar):
+                                    v_new:TABpar=getattr(new_instance,f)
+                                    v_new.copyfrom(v_loaded)
+                                else:
+                                    setattr(new_instance,f,v_loaded)
+                    except Exception as e:
+                        pri.IOError.red(f'Error while reading the file {filename} (setting "{key}" field of {cls_name} item)\n{traceback.format_exc()}\n')
+                fields[key] = new_instance
+            elif isinstance(value, dict) and '__file_ref__' in value:
+                ref_key = value['__file_ref__']
+                if pickle_data:
+                    fields[key] = pickle_data[ref_key]
+                else:
+                    fields[key] = None
+                    info=f'Element: {cls_name} --> field: {key} --> value type: {type(value)}'
+                    info_pickle.append(info)
+                    None
+            else:
+                fields[key] = value
+        for f,v in fields.items():
+            if f in instance.fields: setattr(instance,f,v)
+        #instance.copyfromdiz(fields)
+        return instance
+    
+    def deserialize_list(lst):
+        if isinstance(lst, list):
+            return [deserialize_list(item) for item in lst]
+        else:
+            return deserialize_element(lst)
+    
+    if info_pickle:
+        pri.IOError.red(f'The following non-json serializable items were not found in {filename}:\n'+"\n".join(info_pickle))
+    l=None
+    try:
+        l=deserialize_list(serialized_list)
+    except Exception as e:
+        pri.IOError.red(f'Error while loading the file {filename}!\n{e}\n{traceback.format_exc()}\n')
+        error+=str(e)
+    return l, error
+
+def is_non_json_serializable(value):
+    try:
+        json.dumps(value)
+        return False
+    except (TypeError, OverflowError):
+        return True
+    
+
+def save_list_to_file(l,filename):
+    try:
+        with open(filename, 'wb') as file:
+            pickle.dump(l, file)
+    except Exception as e:
+        print(f'Error while saving the file {filename}!\n{e}\n')
+
+def load_list_from_file(filename):
+    l=None
+    errorMessage=''
+    try:
+        with open(filename, 'rb') as file:
+            l=pickle.load(file)
+    except Exception as e:
+        errorMessage=f'Error while loading the file {filename}!\n{e}\n'
+        pri.IOError.red(errorMessage)
+    return l, errorMessage
+
+if FLAG_SERIALIZED:
+    saveList=save_list_to_file_serialized
+    loadList=load_list_from_file_serialized
+else:
+    saveList=save_list_to_file
+    loadList=load_list_from_file