44c44
< _pymodule = "PyCafe.pyx" 
---
> _pymodule = "PyCafe.pyx" # os.path.basename(__file__)
49a50,52
> cdef object py_cb
> 
> cdef dict openCallbackDictGlobal = {} 
50a54,59
> cdef dict handleMonDictGlobal = {}
> cdef dict monDictGlobal = {}
> cdef dict openDictGlobal = {}
> 
> cdef dict getDictGlobal = {}
> cdef dict putDictGlobal = {}
52c61,64
< include "PyCafeDefs_sf.pxi"
---
> #cdef ccafe.CAFE * _c_cafe
> #_c_cafe = new ccafe.CAFE()
> 
> include "PyCafeDefs.pxi"
83a96
> 
172,179c185
<               
<         DBPMKeeper dbpm
< 
<         bint dbpmInitialized
<         bint BSInitialized
<         bint isBSinCAOnly
<         BSDataHolder bsd
< 
---
>         
213,216c219
<         self.dbpmInitialized = False
<         self.BSInitialized = False
<         self.isBSinCAOnly = False
< 
---
>         
235,240c238
<     def CAFE_version(self):
<         return CAFE_VERSION   
< 
<     def EPICS_version(self):
<         return EPICS_VERSION
< 
---
>    
245c243,250
<         pv_name = handlePV         
---
>         pv_name = handlePV
>         #global openCallbackDictGlobal
>         #openCallbackDictGlobal[cb] = handlePV
>         #september 21 2021
>         global openDictGlobal
>         openDictGlobal[pv_name] = cb 
>        
>         #handle = self.hh.getHandleFromPV(pv_name)
247a253,264
>         #self._c_cafe.channelCreatePolicy.setPyCallbackFlag(True)
>         #self._c_cafe.channelCreatePolicy.setPyConnectHandler(<void *>cb)    
>         #open
>         #false
> 
>     def setPyCallbackConnect(self, pv: str = None, cb: object = None):
>         if None in (pv, cb):
>             return
>         global openDictGlobal
>         openDictGlobal[pv] = cb
>         
>         ##self.hh.setPyConnectCallbackFn(handle, <void *>cb)
274c291,299
<                             self.cs.info(ECA_ALLOCMEM)))                  
---
>                             self.cs.info(ECA_ALLOCMEM)))
>                     '''
>                     _cafeException = CafeException(
>                         _type='CafeError', _source=_METHOD,
>                         _error_code=ECA_ALLOCMEM,
>                         _error_text=self.cs.code(ECA_ALLOCMEM),
>                         _error_info=self.cs.info(ECA_ALLOCMEM))
>                     raise _cafeException
>                     '''
422,424c447,448
<                     ##for i in range(0, len(pvV)):
<                         ##self.setPyCallbackConnect(pvV[i], cb)
<                         #self.setPyConnectCallbackFn(pvV[i], cb)
---
>                     for i in range(0, len(pvV)):
>                         self.setPyCallbackConnect(pvV[i], cb)
473c497
<             ####self.setPyCallbackConnect(pv, cb)
---
>             self.setPyCallbackConnect(pv, cb)
481c505
<                 #print("OPEN WITH NO GIL//==>", pvStr, handle)		                        
---
>                 #print("OPEN WITH NO GIL//==>", pvStr)		                        
486c510
<         except RuntimeError as e:           
---
>         except RuntimeError as e:
501c525
<             raise Exception("{} {} \n{}".format(self._exception_text, _METHOD, e))          
---
>             raise Exception("{} {} \n{}".format(self._exception_text, _METHOD, e))
791c815,816
<        
---
>         global getDictGlobal
> 
800,801c825,827
<         if cb is not None:          
<             crp.setPyHandlerGet(<void *> cb)  # forces when=WITH_CALLBACK_USER_SUPPLIED
---
>         if cb is not None:
>             getDictGlobal[handle] = cb
>             crp.setPyHandlerGet()  # forces when=WITH_CALLBACK_USER_SUPPLIED
859,861c885,888
<         
<         if cb is not None:           
<             crp.setPyHandlerGet(<void *>cb)  # forces when=WITH_CALLBACK_USER_SUPPLIED
---
>         global getDictGlobal
>         if cb is not None:
>             getDictGlobal[handle] = cb
>             crp.setPyHandlerGet()  # forces when=WITH_CALLBACK_USER_SUPPLIED
886,888c913,917
<        
<         if cb is not None:          
<             crp.setPyHandlerPut(<void *>cb)  # forces when=WITH_CALLBACK_USER_SUPPLIED
---
> 
>         global putDictGlobal
>         if cb is not None:
>             putDictGlobal[handle] = cb
>             crp.setPyHandlerPut()  # forces when=WITH_CALLBACK_USER_SUPPLIED
1402c1431
<         #decorator casts handlePV to int
---
>         #decorator casts to handlePV to int
4021c4050
<             return pvdict, statusOverall, status
---
>             return pvdict
5148a5178,5180
>         global monDictGlobal
>         global handleMonDictGlobal
> 
5158c5190
<         
---
>         #global py_cb
5185,5189d5216
<                 mp.setUserArgs(< void * > mpid)
<                 mp.setNoCyCallbackParameters(len(sig.parameters))
<                 mp.setPyCyHandler(<void *> cb)
< 		
< 
5198c5225,5245
<              
---
> 
>                 mp[i].setUserArgs( < void*> mpid)
> 
>                 if len(sig.parameters) == 1:
>                     monDictGlobal[mpid] = cb
>                     mp[i].setPyHandler()
> 		    
>                 elif len(sig.parameters) == 2:
>                     mp[i].setPyCyHandler(<void *> cb)
> 	  
>                 elif len(sig.parameters) == 3:
>                     handleMonDictGlobal[cb] = handleList[i]
>                     mp[i].setPyCyHandlerData(<void *> cb)
>               
>                 else:
>                     _cafeException = CafeException(_type='CafeError', _source=_METHOD,
>                                                        _error_info="The signature of the monitor callback function is not supported. \
> 						Supported fns are: \
>                                                 1) callback(handle) or 2) callback(pvdata, handle, pv_name) ")
>                     raise _cafeException
> 
5236a5284,5285
>         global monDictGlobal
>         global handleMonDictGlobal
5251c5300,5301
<        
---
>         # April 2020 Legacy
>         #global py_cb
5286,5290c5336
<                 sig = inspect.signature(cb[i])	
< 	 
<                 mp[i].setUserArgs(< void * > mpid) #  (<unsigned long *> ptr_mpid)[0])
<                 mp[i].setNoCyCallbackParameters(len(sig.parameters))
<                 mp[i].setPyCyHandler(<void *> cb[i])
---
>                 sig = inspect.signature(cb[i])
5301c5347,5366
<             
---
>                 mp[i].setUserArgs( < void * > mpid) #  (<unsigned long *> ptr_mpid)[0])
> 
>                 if len(sig.parameters) == 1:
>                     monDictGlobal[mpid] = cb[i]
>                     mp[i].setPyHandler()
>                     
>                 elif len(sig.parameters) == 2:
>                     mp[i].setPyCyHandler(<void *> cb[i])
> 	    
>                 elif len(sig.parameters) == 3:
>                     handleMonDictGlobal[cb[i]] = handleList[i]
>                     mp[i].setPyCyHandlerData(<void *> cb[i])
> 
>                 else:
>                     _cafeException = CafeException(_type='CafeError', _source=_METHOD,
>                                                        _error_info="The signature of the monitor callback function is not supported. \
> 						Supported fns are: \
>                                                 1) callback(handle) or 2) callback(pvdata, handle, pv_name) ")
>                     raise _cafeException
> 
5940a6006
> 
5948c6014
< 
---
>  
5969c6035,6036
< 	
---
> 
> 
6044a6112,6114
>         global monDictGlobal
>         global handleMonDictGlobal
>         global py_cb
6046c6116,6117
<             
---
>        
>         py_cb = cb
6049,6050c6120,6121
<             hmd[cb] = mpid ##otherwise cb gets ovewritten when casting to an object
<             
---
>             hmd[cb] = handle ##otherwise cb gets ovewritten when casting to an object
>             #print(hmd)
6052c6123,6133
<                     
---
>             '''
>             print('SIGNATURE//3//:')
>             print(str(sig))
>             for param in sig.parameters.values():
>                 print('Parameter:', param, type(param))
>             print('len1', len(sig.parameters.values()))
>             print('len2', len(sig.parameters))
> 
>             print('monitorid', mpid)
>             '''
> 
6056,6057c6137,6165
<             mp.setNoCyCallbackParameters(len(sig.parameters))
<             mp.setPyCyHandler(<void *> cb)
---
> 
>  
>             if len(sig.parameters) == 1:
>                 ###monDictGlobal[mpid] = cb
> 
>                 mp.setPyHandler()               
>                 # print  (<long>mp.getUserArgs())
> 
>             elif len(sig.parameters) == 2:
>                 mp.setPyCyHandler(<void *> cb)
> 		#mp.setPyHandler()
> 		#mp.setCyCallback(<void *> cb)
>      
>             elif len(sig.parameters) == 3:
>                 #py_cb=cb
>                 #self.hh.addWidget(handle, <void *> cb)
>               
>                 mp.setPyCyHandlerData(<void *> ( py_cb))
>                 #handleMonDictGlobal[cb] = handle
>                 
>                 #mp.setPyHandlerData()
>                 #mp.setCyCallback(<void *> cb)
>             else:
>                 _cafeException = CafeException(
>                     _type='CafeError', _source=_METHOD,
>                     _error_info="The signature of the monitor callback function \
> 		    given by the user is not supported. Valid fns are: \
>                     1) callback(handle) or 2) callback(pvdata, handle, pv_name) ")
>                 raise _cafeException
6096c6204
<         cdef unsigned int mpid_no_coercion
---
>         cdef unsigned int mpidUI
6097a6206,6207
>         global monDictGlobal
>         #global handleMonDictGlobal
6099c6209,6210
< 	
---
> 
> 
6101d6211
<             mpid_no_coercion = mpid
6103c6213
<                 mpid_no_coercion = mpid
---
>                 mpidUI = mpid
6105,6113c6215,6226
<                     status = self._c_cafe.monitorStopWithID(handle, mpid_no_coercion)
<                 time.sleep(0.001)
<                 l = None
<                 if mpid not in list(hmd.values()):
<                     pass #happens when is direct mode in table widget
<                 else:      
<                     l = list(hmd.keys())[list(hmd.values()).index(mpid)]               
<                 if l is not None:             
<                     del hmd[l]
---
>                     status = self._c_cafe.monitorStopWithID(handle, mpidUI)
>                 time.sleep(0.01)
> 
>                 if (status == ICAFE_NORMAL):
>                     #pass
>                     #print (monDictGlobal)
>                     # DELETE ENTRY ONLY IF IT EXISTS!
>                     # if monDictGlobal.has_key(mpidUI):
>                     # Sep 2020 - try without del for testing!
>                     if mpidUI in monDictGlobal.keys():
>                         del monDictGlobal[mpidUI]
> 
6118d6230
<             mids = self.hh.getMonitorIDs(handle)
6121,6129c6233,6265
<             time.sleep(0.001)
<     
<             for monid in mids:
<                 if monid not in list(hmd.values()):
<                     continue
<                 l = list(hmd.keys())[list(hmd.values()).index(monid)]               
<                 if l is not None:                                  
<                     del hmd[l]
<                    	
---
>             time.sleep(0.01)
>            
>         _ncount = 0
>         for key, value in hmd.items():
>             if value == handle:
>                 _ncount += 1
> 
>         for i in range (0, _ncount):             
>             try:   
>                 l = list(hmd.keys())[list(hmd.values()).index(handle)] 
>                 #print (l)
>                 if l is not None:
>                     del hmd[l] 
>             except ValueError:
>                 print("List does not contain handle {0}".format(handle))                  	      
>         #{k:v for k,v in hmd.items() if v != handle}
>         ##for a, v in hmd.items():
>             ##print(a, v)
>             ##print ("DEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEELLLLLLLETE")
>         # Find handle with monitor ID and STOP thst one monitor!
> 
>         if (status == ICAFE_NORMAL):
> 
>             # print "size", self.hh.getNmonitor(handle)
>             mpidUIV = self.hh.getMonitorIDs(handle)
>             # print "size", mpidUIV.size()
> 
>             for i in range(0, mpidUIV.size()):
> 
>                 # if monDictGlobal.has_key(mpidUIV[i]):
>                 if mpidUIV[i] in monDictGlobal.keys():
>                     del monDictGlobal[mpidUIV[i]]
> 
6137a6274
>     # 3
6143d6279
<         cdef int status
6144a6281,6282
>         global monDictGlobal
>         global handleMonDictGlobal
6145a6284
>         cdef int status
6152c6291,6292
<         hmd.clear()
---
>         monDictGlobal.clear()
>         handleMonDictGlobal.clear()
6181a6322
> 
7232,7545d7372
< 
< #if HAVE_BSREAD==1:
< 
< ################################################################################
< 
<     def prepareSFdbpm(self):
<         cdef:
<             vector[string] bpmList
<             vector[unsigned int] bpmHandles        
<             vector[string] bpmDev
<             vector[float] bpmPos
<  
<         self._c_cafe.prepareDBPM(bpmList, bpmHandles, bpmDev, bpmPos) 
< 
<         # for i in range(0, self.bpmDev.size()):
<         #print (bpmPos[i], bpmDev[i] )
< 
<         if not self.dbpmInitialized:         
<             self.dbpm = DBPMKeeper(
<                 bpmList, bpmHandles,  bpmDev, bpmPos)
<             self.dbpmInitialized = True
<         return
< 
< ##################################################################################
< # END def prepareSFdbpm(self)
< ##################################################################################
< 
<     def setSFdbpmBS(self, bint bsFlag=True):
<         return self.dbpm.setBS(bsFlag)
< 
<     def resetSFdbpmBS(self):
<         return self.dbpm.resetBS()
< 
<     def closeSFdbpmBS(self):
<         return self.dbpm.closeBS()
< 
<     def readSFdbpmOffsets(self):
<         return self._c_cafe.readDBPMOffsets(self.dbpm)
<   
<     def getSFdbpm(self):
<     
<         cdef str _METHOD = "getSFdbpm"
< 
<         cdef int status
<         cdef vector[unsigned int] handleV
<         with nogil:
<             status = self._c_cafe.getDBPM(self.dbpm)
< 
<         if status >= ICAFE_ERRNO_BASE:
<             self._c_cafe.printStatusMessage(status)
<         elif status != ICAFE_NORMAL:
<             if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW:
<                 # self._c_cafe.printStatusMessage(status)
<               
<                 handleV = self.dbpm.getHandle()
<                 # for i in range(0, self.dbpm.getNDBPM()):
<                 # if x[i].getStatus !=
<                 #print (self.bpmPos[i], self.bpmDev[i] )
<                 for i in range(0, self.dbpm.getNPV()):
<                     if (self.dbpm.pvd[i].getStatus() != ICAFE_NORMAL):
<                         self._c_cafe.printStatus(handleV[i], status)
< 
<         return dbpmHolderToStruct(self.dbpm)
< 
< ##################################################################################
< # END def  getSFdbpm(self):
< ##################################################################################
< 
< 
<     def getSFdbpmOffs_x(self):
<         return self.dbpm.getOffsetX()
< 
<     def getSFdbpmOffs_y(self):
<         return self.dbpm.getOffsetY()
< 
< ################################################################################
< 
<     def setBS(self, list pv=None, modulo=None, offset=None, int timeoutMS=0):
< 
<         cdef str _METHOD = "setBS"
<         cdef int status = ICAFE_NORMAL
<         cdef unsigned int i
<         cdef bint pFlag = False
< 
<         if isinstance(modulo, numbers.Number):
<             if int(modulo) <= 0:
<                 raise ValueError("{} {} \n{}".format(
<                     self._exception_text, _METHOD,
<                     "modulo input argument must be positive!"))
<         elif not TypeError(modulo, dict):
<            raise Exception("{} {} \n{}".format(
<                self._exception_text, _METHOD,
<                ("modulo input arg, should be of type <class 'numbers.Number'>, "
<                 "else <class 'dict'> {pv_name : modulo}")))
< 
<         if isinstance(offset, (numbers.Number)):
<             if int(offset) < 0:
<                 raise ValueError("{} {} \n{}".format(
<                    self._exception_text, _METHOD,
<                    "offset input argument cannot be negative!"))
<         elif not isinstance(offset, (dict)):
<             raise TypeError("{} {} \n{}".format(
<                 self._exception_text, _METHOD,
<                 ("offset input arg, should be of type <class 'numbers.Number'>, " 
<                  "else <class 'dict'> {pv_name : offset} ")))
<             
<         if self.BSInitialized == True:
<             print("Message from setBS: ONLY A SINGLE STREAM IS ALLOWED")
<             return status
< 
<         cdef vector[string] v
< 
<         if timeoutMS > 0:
<             self.bsd.setTimeout(timeoutMS)
< 
<         if pv is not None:
<             # do this to avoid compiler warning messages
<             for i in range(0, len(pv)):
<                 v.push_back(pv[i])
<             self.bsd.init(v)
< 
<             if isinstance(modulo, (numbers.Number)):
<                 modulo = dict([(pv[i], int(modulo))
<                                for i in range(0, len(pv))])
< 
<             if isinstance(offset, (numbers.Number)):
<                 offset = dict([(pv[i], int(offset))
<                                for i in range(0, len(pv))])
< 
<         if modulo is not None:
<             for eachKey in modulo:
<                 self.bsd.setBSModulo(eachKey, modulo[eachKey])
<         if offset is not None:
<             for eachKey in offset:
<                 self.bsd.setBSOffset(eachKey, offset[eachKey])
< 
<         # self.initBSwithCA()
<         with nogil:
<             self._c_cafe.initBSwithCA(self.bsd)
< 
<         with nogil:
<             self._c_cafe.getBS(self.bsd)
< 
<         with nogil:
<             # status=self._c_cafe.setBS_Step1(self.bsd)
<             status = self._c_cafe.setBS(self.bsd)
< 
<         if status == ICAFE_NORMAL:
<             self.BSInitialized = True
<             self.isBSinCAOnly = False
< 
<         return status
< 
< ################################################################################
< 
<     def initBSwithCA(self):
< 
<         # self.openPrepare()
<         with nogil:
<             self._c_cafe.initBSwithCA(self.bsd)
< 
<         # self.openNowAndWait(0.4)
< 
< 
< ################################################################################
<     def setBS2CA(self, list pv=None):
< 
<         cdef vector[string] v
<         if pv is not None:
<             # do this to avoid compiler warning messages
<             for i in range(0, len(pv)):
<                 v.push_back(pv[i])
<             self.bsd.init(v)
< 
<         with nogil:
<             self._c_cafe.setBS2CAGroup(self.bsd)
<         self.isBSinCAOnly = True
< 
< 
<     def getBSSlim(self):      
<         if self.BSInitialized == False:
<             if self.isBSinCAOnly == False:
<                 print(("Message from getBS: BS stream not initialized;"
<                        "cafe.setBS(pvList) has first to be called."))
<                 return None
< 
<         with nogil:
<             self._c_cafe.getBS(self.bsd)   
< 
< 
<         t1=  time.time()      
<         PVDataV = self.bsd.getPVDataV()
<         
<         pvlist = [None] *  <int>self.bsd.getNPV()
<         #cdef pvdata p1
<     
<         for i in range (0, self.bsd.getNPV()):
<             #p1 = pvdata()
<             #p1 = PVDataHolderToStruct(self.bsd.pvdata[i])
<             pvlist[i]=PVDataHolderToStruct(PVDataV[i])
<             
< 
<         bs_slim = {}
<          
<         for data, handle in zip(pvlist, self.bsd.getHandles()): # self.bsd.getIsBS()):
<             bs_slim[handle] = data
< 
<         t2=  time.time()  
<         print("diff in reading  BSDataHolderToStruc",  t2 - t1)  
<         
< 
<         return bs_slim
< 
< ################################################################################
<     def getBS(self):
< 
<         if self.BSInitialized == False:
<             if self.isBSinCAOnly == False:
<                 print(("Message from getBS: BS stream not initialized;"
<                        "cafe.setBS(pvList) has first to be called."))
< 
<                 return None
<         # CHECK STATUS!!!!
<         #print("getBS in cycafe"       
<         #start = time.time()
< 
<         with nogil:
<             self._c_cafe.getBS(self.bsd)
< 
<         _bsd =  BSDataHolderToStruct(self.bsd)
<         #_bsd.show()
<         return  _bsd #BSDataHolderToStruct(self.bsd)
<         
<         '''     
<         cdef double _pid = 0
<         _handle = self._c_cafe.getHandleFromPV(str('SIN-TIMAST-EVG0:TX-PULSEID'))
<         _stat = self._c_cafe.getCacheDouble(_handle, _pid) 
<         print("cython/cafe/diff in cython ", self.bsd.getPulse_id(), _pid, _pid - self.bsd.getPulse_id()) 
<         t1=  time.time()  
<         print("diff in cython",  t1 - start)  
<         #print("pulse_id in cycafe", self.bsd.getPulse_id())   
<         
<         BSd = BSDataHolderToStruct(self.bsd)       
<         t2=  time.time()  
<         print("diff totol in reading  BSDataHolderToStruc",  t2 - start)  
<         
<         return BSd
<         '''
< 
< ################################################################################
< 
<     def closeBS(self):
<         with nogil:
<             self._c_cafe.closeBS(self.bsd)
<         self.BSInitialized = False
<         self.isBSinCAOnly = False
<         
< 
<     def getTimeoutMSBS(self):
<         return self.bsd.getTimeout()
< 
<     def setTimeoutMSBS(self, int timeoutMS):
<         self.bsd.setTimeout(timeoutMS)
<        
< 
<     def reconnectBS(self):
<         self.bsd.reconnect()
<         
< 
<     def flushBS(self):
<         self.bsd.reconnect()
<         
< 
<     def monitorPulseID(self):
<         with nogil:
<              self._c_cafe.monitorPulseID()
<        
< 
<     def monitorStopPulseID(self):
<         with nogil:
<              self._c_cafe.monitorStopPulseID()
<         
< 
<     def setPulseIDBufferSize(self, handlePV, int bufferSize = 10):
<         cdef str _METHOD = "setPulseIDBufferSize"
<         
<         cdef unsigned int handle = 0
<         if isinstance(handlePV, (int, long)):
<             handle = handlePV
<         elif isinstance(handlePV, (str)):
<             handle = self.checkForHandle(handlePV)
<         else:
<             raise Exception("{} {} \n{}".format(
<                 self._exception_text, _METHOD,
<                 ("First Input argument should be of type <class 'int'> if handle "
<                  "else <class 'str'> if PV.")))
<             
<         self._c_cafe.setPulseIDBufferSize(handle, bufferSize)
<         
< 
<     def setPulseIDBufferSizeAll(self, int bufferSize = 10):
<         self._c_cafe.setPulseIDBufferSizeAll(bufferSize)
<         
< 
< ###################################################################################
< 
<     def setBSInit(self, list pv):
<         self.bsd.init(pv)
<         
< 
< 
< ##################################################################################
< #END: cdef CAFE###################################################################
< ##################################################################################