PaIRS-UniNa 0.2.7__cp310-cp310-macosx_11_0_universal2.whl

PaIRS_UniNa/readcfg.py

@@ -0,0 +1,52 @@
+''' helper functions for reading cfg files'''
+from typing import Tuple,Callable,TextIO,Union
+def readNumCfg(f,ind:int,convFun:Callable,separator=',',comment='%')->Tuple[int,Union [int,float]]:
+  ''' reads a number from a cfg file'''
+  
+  while (line:=f.readline())[0]==comment:
+    ind+=1
+  
+  return  ind+1,convFun(line.strip().split(separator)[0])
+
+def readCfgTag(f:TextIO)->str:
+  ''' returns the cfg tag'''
+  return f.readline()[0:8]
+
+def readNumVecCfg(f,ind:int,convFun,separator=',',comment='%')->Tuple[int,list[Union [int,float]]]:
+  ''' reads a vector of numbers from a cfg file'''
+  
+  while (line:=f.readline())[0]==comment:
+    ind+=1
+  nums=line.strip().split(separator)[0].split('[')[1].split(']')[0].strip()
+
+  return  ind+1,[convFun(num) for num in nums.split(' ')]
+def readCalFile(buffer:str)->Tuple[int,int ,list[float]]:
+    ''' reads the calibration constants from a file
+      buffer is the name of the file
+      if numCostCalib is different from none it is used regardless of the value in  the file
+      In output returns flagCal,numCostCalib,cost 
+    '''
+    try:
+      with open(buffer,'r') as f:
+        tag=readCfgTag(f)
+        
+        if tag != "%SP00015":
+          raise RuntimeError(f'Wrong tag in file: {buffer}') 
+        ind=1
+        ind,flagCal=readNumCfg(f,ind,int)
+        ind,numCostCalib=readNumCfg(f,ind,int)
+        
+        cost=[0]*numCostCalib
+        for i in range(numCostCalib):# dati->NumCostCalib; i++):
+          ind,cost[i]=readNumCfg(f,ind,float)
+      return flagCal,numCostCalib,cost
+        #if "%SP00015"
+        #for index, line in enumerate(f):              pri.Info.white("Line {}: {}".format(index, line.strip()))
+    #except Exception as exc: 
+    except IOError as exc: 
+      raise RuntimeError(f'Error opening the calibration constants file: {buffer}') from exc
+    except ValueError as exc: 
+      raise RuntimeError(f'Error reading line:{ind+1} of file: {buffer}') from exc
+    except IndexError as exc: 
+      raise RuntimeError(f'Error reading array in line:{ind+1} of file: {buffer}') from exc  
+  

PaIRS_UniNa/rqrdpckgs.txt

@@ -0,0 +1,9 @@
+scipy	1.14.0	1.16.1	0
+matplotlib	3.9.0	3.10.6	0
+pillow	10.4.0	11.3.0	0
+numpy	2.0.0	2.3.2	0
+pyside6	6.7.0	6.9.2	0
+unidecode	1.3.0	1.4.0	0
+psutil	6.0.0	7.0.0	0
+debugpy	1.6.6	1.8.16	0
+certifi	2025.7.14	2025.8.3	0

PaIRS_UniNa/stereoPivParFor.py

@@ -0,0 +1,227 @@
+from typing import Tuple#,Callable
+from .PaIRS_pypacks import *
+from .procTools import *
+from .pivParFor import WrapperOutFromPIV
+from .readcfg import readCalFile
+#if Flag_DEBUG_PARPOOL:   import debugpy
+
+
+
+def initStereoPIV(eventFerma,iImg,procId,data:dataTreePar,*args,**kwargs):  
+  ''' this  function is called once per processor before the main function 
+  eventferma is passed to the function called by PIV in order to stop the processing ''' 
+  #prTimeLock(0,f"  initPIV")
+  
+  StereoPIV=data2StereoPIV(data)
+  try:
+    StereoPIV.evalCommonZone() #todo maybe this should be done also before for plotting the common zone
+  except ValueError as exc:
+    pri.Error.white(f"{exc=}, {type(exc)=}")
+  
+
+  StereoPIV.Inp.FlagLog=0
+  #vect=[]
+  #for v in data.PRO.Vect:      vect.append(v.astype(np.intc))
+      
+  #StereoPIV.SetVect([v.astype(np.intc) for v in data.PRO.Vect])
+  if data.FlagMIN:
+    data.compMin.Imin=[[np.zeros(1) for _ in range(data.nframe)] for _ in range(data.ncam)]
+    for c,Iminc in enumerate(data.Imin):
+      for k,filename in enumerate(Iminc):
+        try:
+          data.compMin.Imin[c][k]=np.ascontiguousarray(Image.open(filename))
+        except Exception as inst:  
+            raise (inst)          
+        
+
+  #fatto in modo esplicito da vedere
+  #StereoPIV.Inp.FlagNumThreads=1# of threads used in the processing use 0 for the number of logical processors 
+  StereoPIV.Media=MediaPIV(stepType=StepTypes.spiv)#data.mediaPIV
+  StereoPIV.WraOut =WrapperOutFromPIV(0,eventExit=eventFerma)
+  StereoPIV.fun=PaIRS_lib.GetPyFunction(StereoPIV.WraOut) 
+  StereoPIV.initAlloc(StereoPIV.fun)
+  (flagOut,VarOut)  =procStereoPIV(iImg,procId ,StereoPIV,data,*args,**kwargs)
+  return (flagOut,VarOut,StereoPIV)
+def exitNoLog(flagOut,varOut):
+  ''' exit without printing the log '''
+  varOut[0]=-1
+  return (flagOut,varOut)
+def procStereoPIV(i,procId ,StereoPIV,data:dataTreePar,numUsedProcs,*args,**kwargs):
+  ''' main proc function called for all the images one time per processor 
+    k=0 always
+    In output flagOut and varOut[0] can be:
+      Already processed:      varOut[0]=-1 flagOut=FLAG_PROC[k]|FLAG_READ[k]|FLAG_FINALIZED[k]
+      Error reading:          varOut[0]=i  flagOut=FLAG_READ_ERR[k]
+      Error processing:       varOut[0]=i  flagOut=FLAG_READ[k]
+      Process stoped by user: varOut[0]=-1 flagOut=FLAG_READ[k]
+      Error saving:           varOut[0]=i  flagOut=FLAG_PROC[k]|FLAG_READ[k]
+      Read and processed:     varOut[0]=i  flagOut=FLAG_PROC[k]|FLAG_READ[k]|FLAG_FINALIZED[k]|FLAG_CALLBACK_INTERNAL
+    Use:
+    numCallBackTotOk+=sum(1 if x&FLAG_CALLBACK_INTERNAL else 0 for x in flagOut) 
+        to evaluate the number of total internal callbacks
+    numProcOrErrTot=sum(1 if f else 0 for f  in flagOut)   
+        to evaluate the number of total images processed (after a possible pause)
+    numFinalized=sum(1 if f&FLAG_FINALIZED[0]  else 0 for f  in flagOut)   
+        to evaluate the number of total images correctly  processed   
+
+    where FLAG_FINALIZED_OR_ERR = [ p|e for (p,e) in zip(FLAG_FINALIZED,FLAG_READ_ERR)]
+    numProcOrErrTot=sum(1 if (f&FLAG_FINALIZED_OR_ERR[0])or(not f&FLAG_PROC[0])  else 0 for f  in flagOut)    
+    to delete images 
+    pa='C:\\desk\\dl\\apairs\\jetcross\\'
+    no='zR2jet0_0004a'
+    I =imread([pa no '.png']);
+    I=I*0+1;
+    imwrite(I,[pa no 'black.png']);
+  '''
+  
+  flagOut=0#data.list_pim[i] #0 to be processed, -1 error, 1 correctly processed
+  
+  varOut=[i,'',[]] # The log will be written unless exitNoLog. If FLAG_CALLBACK_INTERNAL will be set then also the internal part will be called. 
+  
+  #if PIV.WraOut.flagFerma!=0: return (flagOut,VarOut)
+  j=i*2
+  kConst=0#useless. In preProc the flags are different for the first and second image in this case we only use the first (i.e. k=0)
+  try:
+    varOut[1]+=f'{data.list_Image_Files[j]}-{data.list_Image_Files[j+1]}'
+    if data.list_eim[j] and data.list_eim[j+1]:  
+      if  data.list_pim[i]&FLAG_FINALIZED[kConst]:
+        flagOut=FLAG_READ[kConst]|FLAG_PROC[kConst]|FLAG_FINALIZED[kConst]  # It has been already processed. Exit without calling the callback  core part
+        #☻prTimeLock(0,f"{i} --> {data.list_Image_Files[j]}   {data.list_Image_Files[j+1]}  {hex(flagOut)}")
+        return exitNoLog(flagOut,varOut)
+      else:
+        if StereoPIV.WraOut.eventExit.is_set():    return exitNoLog(flagOut,varOut)# non si può mettere prima
+        # reading images and transforming 
+        #prTimeLock(0,f"{i} --> {data.list_Image_Files[j]}   {data.list_Image_Files[j+1]}")
+        imgs = [[None] * 2 for i in range(2)]
+        # tbd
+        #if i==2:1/0
+        try:
+          for c in range(2):
+            for k in range(2):
+              if StereoPIV.WraOut.eventExit.is_set(): return exitNoLog(flagOut,varOut)
+              if c==0:
+                nameImg=data.inpPath+data.list_Image_Files[j+k]
+              else:
+                nameImg=data.inpPath+data.list_Image_Files[j+k].replace('_cam0','_cam1')
+              imgs[c][k]=np.ascontiguousarray(Image.open(nameImg),dtype= np.uint16)
+              if data.FlagMIN:
+                if data.FlagTR and i%2:
+                  imgs[c][k]=imgs[c][k]-data.compMin.Imin[c][[1,0][k]]
+                else:
+                  imgs[c][k]=imgs[c][k]-data.compMin.Imin[c][k]
+                imgs[c][k]=np.ascontiguousarray(imgs[c][k],dtype= np.uint16)
+            #iProc=transfIm(data.OUT,flagTransf=0,Images=I1)
+        except Exception as inst:
+          flagOut|=FLAG_READ_ERR[kConst]
+          if data.list_pim[i]&FLAG_READ_ERR[kConst]:varOut[0]=-1# no log already written
+          varOut[1]+=f"\n!!!!!!!!!! Error while reading the image {data.list_Image_Files[j+k]}:\n{inst}\n" 
+          prLock(f'{varOut[1]}')
+          return (flagOut,varOut) #we can exit directly! Not calling the internal part of the callback in case of error
+        
+        # no exception reading images and transforming running the process 
+        flagOut|=FLAG_READ[kConst]
+        #infoPrint.white(os.getpid())
+        try:
+          if StereoPIV.WraOut.eventExit.is_set(): return (flagOut,varOut)
+          err=StereoPIV.run(imgs)
+        except Exception as inst:
+          #raise (inst)
+          if ( data.list_pim[i] &FLAG_READ[kConst]):varOut[0]=-1# no log already written
+          #dum=str(inst.__cause__).split('\n')[3] #solved
+          dum='\n'.join(str(inst.args[0]).split('\n')[3:])
+          #varOut[1]+=f"\n!!!!!!!!!! Error while processing the above image pair: {dum}"  
+          varOut[1]+=f"\n!!!!!!!!!! Error while processing data:\n{dum}\n"  
+          #prLock(f'{varOut[1]}')
+          return (flagOut,varOut) #we can exit directly! Not calling the internal part of the callback in case of error
+        try:# no exception running the process 
+          if err==-1000: #interrotto 
+              return exitNoLog(flagOut,varOut) #we can exit directly no log ! 
+          else:
+            # Finalizing the process (means  transformations and saving data)
+            flagOut|=FLAG_PROC[kConst]# per completezza aggiungo anche processato
+            #x,y,u,v=transfVect(data.OUT,StereoPIV) # No transformation for Spiv          #[StereoPIV.x,StereoPIV.y,StereoPIV.z,StereoPIV.u,StereoPIV.v,StereoPIV.w]
+            nameFields=StereoPIV.Media.namesPIV.instVelFields
+            #otherVars=[getattr(StereoPIV,f) for f in nameFields[4:] ]
+            #campoVel=[x,y,u,v] +transfIm(data.OUT,flagTransf=1,Images=otherVars,flagRot=1)
+            campoVel=[getattr(StereoPIV,f) for f in nameFields ]
+            nameVar=StereoPIV.Media.namesPIV.instVel
+            StereoPIV.Media.sum(campoVel)  
+            try:
+              saveResults(data,i+1,campoVel,nameVar)
+            except Exception as inst:   
+              varOut[1]+=f"\n!!!!!!!!!! Error while saving the results:\n{str(inst)}\n"   
+              #prLock(f'{varOut[1]}')
+              varOut[0]=i# In any case the log will be written. If FLAG_CALLBACK_INTERNAL will be set then also the internal part will be called. 
+              return (flagOut,varOut) #we can exit directly! Not calling the internal part of the callback in case of error
+            varOut[1]+="\n"+printPIVLog(StereoPIV.PD0)+printPIVLog(StereoPIV.PD1)
+            flagOut|=FLAG_FINALIZED[kConst]
+            varOut[0]=i# In any case the log will be written. If FLAG_CALLBACK_INTERNAL will be set then also the internal part will be called. 
+            flagOut|=FLAG_CALLBACK_INTERNAL# Verrà chiamata la callback
+        except Exception as inst:
+          varOut[1]+=f"\n!!!!!!!!!! Error while finalizing the PIV process:\n{str(inst)}\n"  
+          #prLock(f'{varOut[1]}')
+          return (flagOut,varOut)
+    else:#if data.list_eim[j] and data.list_eim[j+1]:  
+      flagOut|=FLAG_READ_ERR[kConst]
+      if  data.list_pim[i]&FLAG_READ_ERR[kConst]:varOut[0]=-1# no log already written
+      jj=j+1 if data.list_eim[j] else j
+      varOut[1]+=f"\n!!!!!!!!!! Error while reading the image {data.list_Image_Files[jj]}:\nThe image file is missing!\n"
+      #prLock(f'{varOut[1]}')
+  except :
+    flagOut|=FLAG_GENERIC_ERROR
+    varOut[0]=i# In any case the log will be written. If FLAG_CALLBACK_INTERNAL will be set then also the internal part will be called. 
+    varOut[1]+=printException(flagMessage=True)
+  
+  # to del  ma il resto dove va
+  #varOut=[i,stampa,[]] if flagOut&FLAG_FINALIZING_PROC_OK[0] else [-1,stampa,[]]
+  if (not procId%numUsedProcs) and flagOut&FLAG_FINALIZED[0]: # copiare l'img nella coda è un operazione onerosa. TA ha deciso che si copia solo quando serve
+    #prLock(f'procMIN Main proc i={i}')
+    varOut[2]=campoVel#VarOut=[i,stampa,Var]
+  
+
+  
+  return (flagOut,varOut)
+
+def finalStereoPIV(procId, PIV,data,*args,finalPIVPIppo=4 ,**kwargs):
+  #prLock(f'finalPIV  procId={procId}')
+  return PIV.Media
+
+def saveAndMean(procId,flagHasWorked,med,data,*args,**kwargs):
+  ''' saveAndMean is the wrapUp function called once per processor  '''
+  if flagHasWorked:
+    data.mediaPIV.sumMedia(med)
+  return data.mediaPIV
+
+def callBackStereoPIV(flag,perc,procId,flagOut,name,VarOut,signal_res):
+  ''' 
+    flag=true new data False just check exit
+    perc= precentage done
+    flagOutFromTasks,varOutFromTask Out varibles from task  e.g.:
+      flagOut=1 #0 to be processed, -1 error, 1 correctly processed
+      varOutFromTask whatever for now a string
+      name current element in names
+    to stop the process the return value should be True otherwise sleep  
+  '''
+  global FlagStopWorkers
+  
+  if flag:
+    i=VarOut[0]
+    stampa=VarOut[1]
+    Var=VarOut[2]
+    #pr(f'Callback {i}         getpid {os.getpid()}      {len(Var)}')
+    #prLock(f'Callback {i}         getpid {os.getpid()}   ')
+    signal_res.emit(procId,i,flagOut,Var,stampa)
+    VarOut[2]=[]#altrimenti salvo le img 
+    '''
+    if i==0:
+      callBackPIV.flagStop=True
+    if(callBackPIV.flagStop):
+      if i>=2:
+        callBackPIV.flagStop=False
+        FlagStopWorkers[0]=True
+        return True
+    #''' 
+  if FlagStopWorkers[0]:
+    return True
+  else:
+    return False     

PaIRS_UniNa/tAVarie.py

@@ -0,0 +1,215 @@
+''' printing routines'''
+from enum import Enum
+from time import time
+
+
+
+def  commenti():
+  '''
+  ## Descrizione di alcuni commenti (Doppio ## per titolo Anche singolo #)
+  ### Sotto titolo (###)
+  #### Sotto titolo (####)
+
+  Questo è un link interno [commenti] o esterno [https://dartdoc.takyam.com/articles/doc-comment-guidelines/#markup].
+
+  L'editor fa un wrap automatico Per andare a capo mettere una linea vuota altrimenti il testo della linea successiva si attacca a quella precedente.
+  
+  Lista formattata * o numero seguito da punto
+  1. item continues until next list item or blank line
+  2. next item
+
+  Non funzionano per python:
+  * Per il corsivo utilizzare _single underscore_ or *single asterisk*. Per Boldface **double asterisk** or __double underscore__
+  * Inserire 5 spazi ed una linea vuota per mettere del codice che poi verrà formattato
+
+    $ def  commenti():
+      void commenti(){}
+
+  in alternativa usare (alt96) anche se non mi sembra che funzioni `def  commenti()` (note the backquotes)
+  '''
+  return
+
+
+
+PrintTAPriority=Enum('PrintTAPriority' ,['never', 'veryLow', 'low', 'medium', 'mediumHigh', 'high', 'always' ])
+'''
+* never non stampa nulla
+* always stampa sempre
+* Altro stampa solo se la priorità impostata durante la fase di stampa è maggiore uguale di quella impostata nella classe (eccezione per PrintTAPriority.always)
+* quindi impostando  PrintTA.flagPriority=PrintTAPriority.always non stampa nulla
+* quindi impostando  PrintTA.flagPriority=PrintTAPriority.never  stampa tutto 
+''' 
+
+class PrintTA ():
+  '''
+  ## Usare al posto di Print con qualcosa del tipo
+
+  * printTA = PrintTA(PrintTA.blue, PrintTA.faceStd,  PrintTAPriority.medium)
+  * printTA.pr('blue',color=printTA.blue)
+  * printTA.pr('green',color=printTA.green)
+  * printTA.pr('yellow',color=printTA.yellow)
+  * printTA.pr('magenta',color=printTA.magenta)
+  * printTA.pr('cyan',color=printTA.cyan)
+  * printTA.pr('white faceUnderline plus faceItalic',color=printTA.white,face=printTA.faceUnderline+printTA.faceItalic)
+  * printTA.err('Error always bold and','red')
+  * printTA.pri.Time('cyan with time',color=printTA.cyan) 
+
+  Per disattivare la stampa:
+  * PrintTA.flagPriority=PrintTAPriority.always
+
+'''
+
+  faceBold = ';1'
+  faceItalic = ';3'
+  faceUnderline = ';4'
+  faceStd = ''
+
+  stdCol = '0'
+  red = '31'
+  green = '32'
+  yellow = '33'
+  blue = '34'
+  magenta = '35'
+  cyan = '36'
+  white = '37'
+  _tAPrintESC = '\x1B['
+  _tAPrintLAST = 'm'
+  _tAPrintRESET = '\x1B[0m'
+  flagPriority=PrintTAPriority.medium
+  startTime=time()
+  def __init__(self,color='37',face='',flagPriority=PrintTAPriority.medium, prefix='',suffix=''):
+    self.face =face 
+    self.color=color
+    self.prefix=prefix
+    self.flagPriority=flagPriority
+    self.suffix=suffix
+    
+  def internalPrint(self, *args,**kwargs): 
+    ''' change for a different print function'''
+    print(*args,**kwargs,flush=True)
+
+  
+  # [https://en.wikipedia.org/wiki/ANSI_escape_code#SGR_parameters]
+  # print in color with priority
+  # msg text to print
+  # color one of PrintTA.color (e.g. PrintTA.red)
+  # face  one of   PrintTA.bold, PrintTA.italic, PrintTA.underline or PrintTA.stdFace
+  # pri one of PrintTAPriority
+  
+  def pr(self,   *args,color=None, face=None, pri=None,**kwargs):
+    ''' the printing function '''
+    #if self.flagPriority is  PrintTAPriority.never: 
+    if PrintTA.flagPriority is  PrintTAPriority.always: 
+      return
+    if color is None: 
+      color=self.color
+    if face is None: 
+      face=self.face
+    if pri is None :
+      pri=self.flagPriority
+    if pri.value < PrintTA.flagPriority.value: 
+      return
+    self.internalPrint(f'{self._tAPrintESC}{color}{face}{self._tAPrintLAST}{self.prefix}',end='')
+    self.internalPrint(*args,f'{self.suffix}{self._tAPrintRESET}',**kwargs)
+    
+    #self.internalPrint(f'{self._tAPrintESC}{color}{face}{self._tAPrintLAST}{self.prefix}',*args,f'{self.suffix}{self._tAPrintRESET}',**kwargs)
+
+  def err(self, *args,**kwargs):
+    ''' print error always bold and red''' 
+    self.pr( color= PrintTA.red, face= PrintTA.faceBold, pri= PrintTAPriority.medium,*args,**kwargs)
+
+  def  prTime(self, *args,flagReset=0,color=None, face=None, pri=None,**kwargs):
+    ''' 
+    flagreset==0 stampa senza reset (tempo incremetale )
+    flagreset==1 stampa e reset origin (tempo incremetale riazzera l'origine dei tempi)
+    flagreset==2 stampa senza tempo  e reset origin
+    flagreset==3 fa solo il reset dei tempi origin
+     '''
+    if PrintTA.flagPriority is  PrintTAPriority.always: 
+      return
+
+
+    if 0<=flagReset<=1: 
+      self.pr(f'Deltat={time()-PrintTA.startTime}  -- ',*args, color=color, face=face, pri=pri,**kwargs)
+    elif flagReset==2:
+      self.pr(*args, color=color, face=face, pri=pri,**kwargs)
+    if flagReset>0: 
+      PrintTA.startTime=time()
+  def printEvidenced(self,*args,sep='*', numLinee=4,numSep=20,color=None, face=None, pri=None,**kwargs):
+    if PrintTA.flagPriority is  PrintTAPriority.always: 
+      return
+    dum=sep*numSep
+    separator=f'{dum}\n'*(numLinee-1)+dum
+    self.pr(separator,color=color, face=face, pri=pri)
+    self.pr(*args, color=color, face=face, pri=pri,**kwargs)
+    self.pr(separator,color=color, face=face, pri=pri)
+
+
+
+def testPr():
+    ''' can be used to test the priorities'''
+    PrintTA(PrintTA.white, PrintTA.faceStd,  PrintTAPriority.never).pr ('never')
+    PrintTA(PrintTA.white, PrintTA.faceStd,  PrintTAPriority.medium).pr ('medium')
+    PrintTA(PrintTA.white, PrintTA.faceStd,  PrintTAPriority.high).pr ('high')
+    PrintTA(PrintTA.white, PrintTA.faceStd,  PrintTAPriority.always).pr ('always')
+
+
+
+class ColorPrint:
+    def __init__(self,flagTime=False,prio=PrintTAPriority.medium,faceStd=PrintTA.faceStd,flagFullDebug=False):
+        self.flagTime=flagTime
+        self.prio=prio
+        self.faceStd=faceStd
+        self.flagFullDebug=flagFullDebug
+        self.setPrints()
+
+    def setPrints(self):
+        if self.flagTime:
+            self.white = lambda flagReset=0, *args, **kwargs: PrintTA(PrintTA.white, self.faceStd,  self.prio).prTime(flagReset,*args,**kwargs)
+            self.red = lambda flagReset=0, *args, **kwargs: PrintTA(PrintTA.red, self.faceStd,  self.prio).prTime(flagReset,*args,**kwargs)
+            self.green = lambda flagReset=0, *args, **kwargs: PrintTA(PrintTA.green, self.faceStd,  self.prio).prTime(flagReset,*args,**kwargs)
+            self.blue = lambda flagReset=0, *args, **kwargs: PrintTA(PrintTA.blue, self.faceStd,  self.prio).prTime(flagReset,*args,**kwargs)
+            self.cyan = lambda flagReset=0, *args, **kwargs: PrintTA(PrintTA.cyan, self.faceStd,  self.prio).prTime(flagReset,*args,**kwargs)
+            self.magenta = lambda flagReset=0, *args, **kwargs: PrintTA(PrintTA.magenta, self.faceStd,  self.prio).prTime(flagReset,*args,**kwargs)
+            self.yellow = lambda flagReset=0, *args, **kwargs: PrintTA(PrintTA.yellow, self.faceStd,  self.prio).prTime(flagReset,*args,**kwargs)
+        else:
+            self.white = PrintTA(PrintTA.white, self.faceStd,  self.prio).pr 
+            self.red = PrintTA(PrintTA.red, self.faceStd,  self.prio).pr
+            self.green = PrintTA(PrintTA.green, self.faceStd,  self.prio).pr
+            self.blue = PrintTA(PrintTA.blue, self.faceStd,  self.prio).pr
+            self.cyan = PrintTA(PrintTA.cyan, self.faceStd,  self.prio).pr
+            self.magenta = PrintTA(PrintTA.magenta, self.faceStd,  self.prio).pr
+            self.yellow = PrintTA(PrintTA.yellow, self.faceStd,  self.prio).pr
+
+#if prio is assigned to never, in the gPaIRS initializiation the printing is deactivated, otherwise activated
+#if prio is > veryLow, then by default the printing is activated after gPaIRS initialization
+#flagFullDebug=True means that the printing is available only if fullDebug mode is active
+class GPaIRSPrint:
+    def __init__(self):
+        self.General=ColorPrint(prio=PrintTAPriority.medium)
+        self.Info=ColorPrint(prio=PrintTAPriority.medium)
+        self.Time=ColorPrint(prio=PrintTAPriority.veryLow,flagTime=True,faceStd=PrintTA.faceUnderline)
+        self.Error=ColorPrint(prio=PrintTAPriority.medium,faceStd=PrintTA.faceBold)
+        self.Process=ColorPrint(prio=PrintTAPriority.veryLow)
+        self.Callback=ColorPrint(prio=PrintTAPriority.veryLow)
+        self.Geometry=ColorPrint(prio=PrintTAPriority.veryLow,flagFullDebug=True)
+
+pri=GPaIRSPrint()
+
+if __name__ == '__main__':
+  printTA = PrintTA(PrintTA.blue, PrintTA.faceStd,  PrintTAPriority.medium)
+  printTA.pr('blue',color=printTA.blue)
+  printTA.pr('green',color=printTA.green)
+  printTA.pr('yellow',color=printTA.yellow)
+  printTA.pr('magenta',color=printTA.magenta)
+  printTA.pr('cyan',color=printTA.cyan)
+  printTA.pr('white faceUnderline plus faceItalic',color=printTA.white,face=printTA.faceUnderline+printTA.faceItalic)
+  
+  printTA.err('Error always bold and','red')
+  printTA.pri.Time('cyan with time',color=printTA.cyan)
+  pri.Time.blue(0,'taPrintTime')
+  printTA.flagPriority=PrintTAPriority.always    
+  printTA.pri.Time('Non è stampato',color=printTA.cyan)
+  #/// Stampa in rosso bold ed a PrintTAPriority.Always
+  #void err(msg) => pr(msg, color: red, face: faceBold, pri: PrintTAPriority.always);
+