#distutils: language = c++ # file: PyCafe.pyx cimport PyCafe as ccafe import numpy as np cimport numpy as cnp from cpython cimport array import array from cython.view cimport array as cvarray from libc.stdlib cimport malloc, free from cython.operator cimport dereference as deref, preincrement as inc from cython cimport view import ctypes import time import timeit import os import cython import inspect import sys #from libcpp.string cimport string import Cython.Compiler.Options Cython.Compiler.Options.annotate=True include "PyCafeDefs.pxi" cdef dict monDictGlobal={} ################################################################################## cdef class CyCafe: cdef: ccafe.CAFE *_c_cafe double valFloat #cython float64 string valStr int valInt #double * valFloatArray #cython float64 #int * valIntArray #dbr_string_t * valStringArray vector[string] vStr vector[double] vFloat #cython float64 vector[dbr_long_t] vInt HandleHelper hh PolicyHelper ph CAFEException_pv expv CAFEException_open exopen CAFEStatus cs CAFEStatusSeverity css ####PyGILState_STATE gstate tuple pythonVersion bint haveExceptions ChannelRegalia channelInfo #list moncbList #list monidList #dict monDict str exString def __cinit__(self): self._c_cafe = new ccafe.CAFE() if self._c_cafe is NULL: raise MemoryError() self.cs =self._c_cafe.getCafeStatus() ##self.css=self._c_cafe_getCafeStatusSeverity() self.pythonVersion=sys.version_info[0:4] self.haveExceptions=True self.exString="EXCEPTION RAISED IN PyCafe.pyx:" #self.moncbList =[] #self.monidList=[] #self.monDict={} #Required with gil for callbacks #However seems to work without this call ####Py_Initialize() ####PyEval_InitThreads() def __dealloc__(self): del self._c_cafe ################################################################################## def init(self): return self._c_cafe.init() ################################################################################## def withExceptions(self, bint exceptions=True): self.haveExceptions=exceptions return self.haveExceptions #def getMonidList(self): # return self.monidList #def getMoncbList(self): # return self.moncbList #def getMonDict(self): # return self.monDict ################################################################################## def open(self, pv): cdef str _METHOD_="open(pv)" cdef vector[string] pvV cdef vector[unsigned int] handleV cdef bytes py_string if isinstance(pv, (list)): for i in range(0, len(pv)): if isinstance(pv[i], unicode): py_string = (pv[i]).encode('UTF-8') pvV.push_back( py_string ) elif isinstance(pv[i], bytes): pvV.push_back( (pv[i]).encode('utf8') ) else: print ("Unknown type in {}".format(_METHOD_)) try: status=self._c_cafe.openV(pvV, handleV) except RuntimeError as e: if isinstance (e.args, tuple): if 'CAFEException' in (e.args[0]): _cyCafeException = CyCafeException(_type='cafe', _source=_METHOD_, \ _ec=ECA_ALLOCMEM, _et=self.cs.code(ECA_ALLOCMEM), _ei=self.cs.info(ECA_ALLOCMEM)) raise Exception(_cyCafeException) else: raise Exception("{} {} {}".format(self.exString, _METHOD_, e.what())) return handleV elif not isinstance(pv, (bytes,str)): raise Exception("{} {} {}".format(self.exString, _METHOD_, \ "Input argument, pv, should be ")) cdef unsigned int handle=0 try: self._c_cafe.open(pv, handle) except RuntimeError as e: if isinstance (e.args, tuple): if 'CAFEException' in (e.args[0]): _cyCafeException = CyCafeException(_type='cafe',_source=_METHOD_, _handle=handle, _pv=pv, \ _ec=ECA_ALLOCMEM, _et=self.cs.code(ECA_ALLOCMEM), _ei=self.cs.info(ECA_ALLOCMEM)) raise Exception(_cyCafeException) else: raise Exception("{} {} {}".format(self.exString, _METHOD_, e.what())) #print ("******************** HANDLE *******", handle); return handle ################################################################################## def openNoWait(self): #self._c_cafe.channelOpenPolicy.setFlushSendBufferKind(WITH_PEND_EVENT) #self._c_cafe.channelOpenPolicy.setWhenToFlushSendBuffer(FLUSH_DESIGNATED_TO_CLIENT) with nogil: self._c_cafe.openNoWait() return def openPrepare(self): #self._c_cafe.channelOpenPolicy.setFlushSendBufferKind(WITH_PEND_EVENT) #self._c_cafe.channelOpenPolicy.setWhenToFlushSendBuffer(FLUSH_DESIGNATED_TO_CLIENT) with nogil: self._c_cafe.openPrepare() return def openGroupPrepare(self): #self._c_cafe.channelOpenGroupPolicy.setFlushSendBufferKind(WITH_PEND_EVENT) #self._c_cafe.channelOpenGroupPolicy.setWhenToFlushSendBuffer(FLUSH_DESIGNATED_TO_CLIENT) with nogil: self._c_cafe.openGroupPrepare() return def setOpenDefaultPendTime(self, double timeout): return self._c_cafe.channelOpenPolicy.setDefaultTimeout(timeout) def getOpenDefaultPendTime(self): return self._c_cafe.channelOpenPolicy.getDefaultTimeout() ################################################################################## def openNow(self): #self._c_cafe.channelOpenPolicy.flushSendBufferNow() #self._c_cafe.channelOpenPolicy.setWhenToFlushSendBuffer(FLUSH_NOW) #self._c_cafe.channelOpenPolicy.setFlushSendBufferKind(WITH_PEND_EVENT) with nogil: self._c_cafe.openNow() return ################################################################################## def openNowAndWait(self, double timeout): #self._c_cafe.channelOpenPolicy.setTimeout(timeout) #self._c_cafe.channelOpenPolicy.flushSendBufferNow() #reset #self._c_cafe.channelOpenPolicy.setWhenToFlushSendBuffer(FLUSH_NOW) #self._c_cafe.channelOpenPolicy.setFlushSendBufferKind(WITH_PEND_EVENT) #self._c_cafe.channelOpenPolicy.setTimeoutToDefault() with nogil: self._c_cafe.openNowAndWait(timeout) return ################################################################################## ################################################################################## def openGroupNowAndWait(self, double timeout): #self._c_cafe.channelOpenGroupPolicy.setTimeout(timeout) #self._c_cafe.channelOpenGroupPolicy.flushSendBufferNow() #reset #self._c_cafe.channelOpenGroupPolicy.setWhenToFlushSendBuffer(FLUSH_NOW) #self._c_cafe.channelOpenGroupPolicy.setFlushSendBufferKind(WITH_PEND_EVENT) #self._c_cafe.channelOpenGroupPolicy.setTimeoutToDefault() with nogil: self._c_cafe.openGroupNowAndWait(timeout) return ################################################################################## ################################################################################## def openGroupNowAndWaitForInputGroups(self, double timeout, groupHandles): cdef str _METHOD_="openGroupNowAndWaitForInputGroups" cdef vector[unsigned int] hList if isinstance(groupHandles, (list)) == 1: for i in range (0, len(groupHandles)): if isinstance(groupHandles[i], (int,long)) == 1: hList.push_back(groupHandles[i]) elif isinstance(groupHandles[i], (str)) == 1: hList.push_back(self.hh.getGroupHandleFromGroupName(groupHandles[i])) else: raise Exception("{} {} {}".format(self.exString, _METHOD_, \ "List input arguments, should be if group handle, else if group name")) elif isinstance(groupHandles, (int,long)) == 1: hList.push_back(groupHandles) elif isinstance(groupHandles, (str)) == 1: hList.push_back(self.hh.getGroupHandleFromGroupName(groupHandles)) else: raise Exception("{} {} {}".format(self.exString, _METHOD_, \ "Second input argument (if not a list), should be if group handle, else if group name")) #list to vector with nogil: self._c_cafe.groupOpenNowAndWait(timeout, hList) return ################################################################################## def openMonitorPrepare(self): #self._c_cafe.channelMonitorPolicy.setFlushSendBufferKind(WITH_FLUSH_IO) #self._c_cafe.channelMonitorPolicy.setWhenToFlushSendBuffer(FLUSH_DESIGNATED_TO_CLIENT) with nogil: self._c_cafe.openMonitorPrepare() return ################################################################################## def openMonitorNow(self): #self._c_cafe.channelMonitorPolicy.flushSendBufferNow() #reset #self._c_cafe.channelMonitorPolicy.setWhenToFlushSendBuffer(FLUSH_NOW) #self._c_cafe.channelMonitorPolicy.setFlushSendBufferKind(WITH_FLUSH_IO) with nogil: self._c_cafe.openMonitorNow() time.sleep(0.1) return ################################################################################## ################################################################################## def getMonitorWhenToFlushSendBuffer(self): return self._c_cafe.channelMonitorPolicy.getWhenToFlushSendBuffer() ################################################################################## ################################################################################## def openMonitorNowAndWait(self, double timeout): #self._c_cafe.channelMonitorPolicy.setTimeout(timeout) #self._c_cafe.channelMonitorPolicy.flushSendBufferNow() #time.sleep(timeout) #reset #self._c_cafe.channelMonitorPolicy.setWhenToFlushSendBuffer(FLUSH_NOW) #self._c_cafe.channelMonitorPolicy.setFlushSendBufferKind(WITH_FLUSH_IO) with nogil: self._c_cafe.openMonitorNowAndWait(timeout) return ################################################################################## def ca_pend_event(self, double timeout): self._c_cafe._ca_pend_event(timeout) return def ca_pend_io(self, double timeout): self._c_cafe._ca_pend_io(timeout) return def ca_poll(self): with nogil: self._c_cafe._ca_poll() return def ca_flush_io(self): with nogil: self._c_cafe._ca_flush_io() return ################################################################################## def setChannelRequestPolicyGet(self, handlePV, ChannelWhenToFlushSendBufferPolicyKind when, \ ChannelWaitForResponsePolicyKind wait, ChannelRequestPolicyKind method, \ object cb=None): cdef str _METHOD_="setChannelRequestPolicyGet" if isinstance(handlePV, (int,long)) == 1: handle=handlePV elif isinstance(handlePV, (str)) == 1: handle=self.checkForHandle(handlePV) else: raise Exception("{} {} {}".format(self.exString, _METHOD_, \ "First Input argument should be if handle, else if PV")) global py_cb_handle_get cdef ChannelRequestPolicy cp self.ph.getChannelRequestPolicyGet(handlePV, cp) if when: cp.setWhenToFlushSendBuffer(when) if wait: cp.setWaitKind(wait) if method: cp.setMethodKind(method) if cb: py_cb_handle_get=cb cp.setPyHandlerGet() #forces when=WITH_CALLBACK_USER_SUPPLIED self.ph.setChannelRequestPolicyGet(handlePV, cp) return ################################################################################## ################################################################################## def setCallbackGet(self, handlePV, object cb=None): cdef str _METHOD_="setCallbackGet" cdef ChannelRequestPolicy cp self.ph.getChannelRequestPolicyGet(handlePV, cp) if isinstance(handlePV, (int,long)) == 1: handle=handlePV elif isinstance(handlePV, (str)) == 1: handle=self.checkForHandle(handlePV) else: raise Exception("{} {} {}".format(self.exString, _METHOD_, \ "First input argument should be if handle, else if PV")) global py_cb_handle_get if cb: py_cb_handle_get=cb cp.setPyHandlerGet() #forces when=WITH_CALLBACK_USER_SUPPLIED else: cp.setMethodKind(WITH_CALLBACK_DEFAULT) self.ph.setChannelRequestPolicyGet(handlePV, cp) return ################################################################################## ################################################################################## def setCallbackPut(self, handlePV, object cb=None): cdef str _METHOD_="setCallbackPut" cdef ChannelRequestPolicy cp self.ph.getChannelRequestPolicyPut(handlePV, cp) if isinstance(handlePV, (int,long)) == 1: handle=handlePV elif isinstance(handlePV, (str)) == 1: handle=self.checkForHandle(handlePV) else: raise Exception("{} {} {}".format(self.exString, _METHOD_, \ "First input argument, should be if handle, else if PV")) global py_cb_handle_put if cb: py_cb_handle_put=cb cp.setPyHandlerPut() #forces when=WITH_CALLBACK_USER_SUPPLIED else: cp.setMethodKind(WITH_CALLBACK_DEFAULT) self.ph.setChannelRequestPolicyPut(handlePV, cp) return ################################################################################## ################################################################################## def setTimeout(self, timeout): return self.ph.setTimeout(timeout) ################################################################################## ################################################################################## def getTimeoutGet(self): cdef double minValue,p,g minValue=0 p=0 g=0 self.ph.getTimeoutMin(p,g) minValue=g self.ph.getTimeoutMax(p,g) if (g < minValue): minValue=g return minValue ################################################################################## ################################################################################## def getTimeoutPut(self): cdef double minValue,p,g minValue=0 p=0 g=0 self.ph.getTimeoutMin(p,g) minValue=p self.ph.getTimeoutMax(p,g) if (p < minValue): minValue=g return minValue ################################################################################## ################################################################################## def setSelfGoverningTimeout(self, bint b): return self.ph.setSelfGoverningTimeout(b) ################################################################################## ################################################################################## # Synchronous Groups ################################################################################## def setSGTimeout(self, double timeout): return self.ph.setSGTimeout(timeout) ################################################################################## ################################################################################## def getSGTimeoutGet(self): cdef double minValue,p,g minValue=0 p=0 g=0 self.ph.getSGTimeoutMin(p,g) minValue=g self.ph.getSGTimeoutMax(p,g) if (g < minValue): minValue=g return minValue ################################################################################## ################################################################################## def getSGTimeoutPut(self): cdef double minValue,p,g minValue=0 p=0 g=0 self.ph.getSGTimeoutMin(p,g) minValue=p self.ph.getSGTimeoutMax(p,g) if (p < minValue): minValue=p return minValue ################################################################################## ################################################################################## def setSGSelfGoverningTimeout(self, bint b): cdef PolicyHelper ph return ph.setSGSelfGoverningTimeout(b) ################################################################################## ################################################################################## def attachContext(self, handlePV): cdef str _METHOD_="attachContext" cdef unsigned int handle=0 if isinstance(handlePV, (int,long)) == 1: return self._c_cafe.attachContextByHandle(handlePV) elif isinstance(handlePV, (str)) == 1: return self._c_cafe.attachContextByPVName(handlePV) else: raise Exception("{} {} {}".format(self.exString, _METHOD_, \ "First input argument, should be if handle, else if PV")) ################################################################################## ################################################################################## def loadCollectionsFromXML(self, const char * fileName): with nogil: self._c_cafe.loadCollectionsFromXML(fileName) return ################################################################################## ################################################################################## def loadGroupsFromXML(self, const char * fileName): with nogil: self._c_cafe.loadGroupsFromXML(fileName) return ################################################################################## def devicePositionMap(self, const char * collectionName): p=[] d=[] cdef map[float, string] mmfs cdef map[float, string].iterator it self._c_cafe.devicePositionMap(collectionName, mmfs) it= mmfs.begin() tup=() #tuple while it != mmfs.end(): tup=deref(it) p.append(tup[0]) d.append(tup[1]) inc(it) return d,p def devicePositionV(self, const char * collectionName): cdef str _METHOD_="devicePositionV(self, const char * collectionName)" #p=[] #d=[] cdef vector[string] dev cdef vector[float] pos status=self._c_cafe.devicePositionV(collectionName, dev, pos) if status != ICAFE_NORMAL: raise Exception("{} {} {} {} {} {}".format(self.exString, _METHOD_, \ "status=", status, self.cs.code(status), self.cs.code(status) )) #for i in range (0, dev.size()): #d.append(dev[i]) #p.append(pos[i]) return dev, pos ################################################################################## def groupList(self): cdef vector[string] gList #conservative guess gList.reserve(36) self._c_cafe.groupList(gList) #Place in list to avoid this warning: # warning: comparison between signed and unsigned integer expressions #gl=[] #for i in range (0, len(gList)): # gl.append(gList[i]) return gList ################################################################################## def getMonitorIDInCallback(self, handle): return self.hh.getUsrArgsAsUInt(handle) def getDataTypeInCallback(self, handle): return self.hh.getDataTypeCB(handle) def getDbrDataTypeInCallback(self, handle): return self.hh.getDbrDataTypeCB(handle) def getDbrBaseInCallback(self, handle): return self.hh.getCafeDbrTypeCB(handle) ################################################################################## def getHandlesFromWithinGroup(self, gHandleName): cdef str _METHOD_="getHandlesFromWithinGroup(gHandleName)" cdef unsigned int groupHandle=0 if isinstance(gHandleName, (int,long)) == 1: groupHandle=gHandleName elif isinstance(gHandleName, (str)) == 1: groupHandle=self.hh.getGroupHandleFromGroupName(gHandleName) else: raise Exception("{} {} {}".format(self.exString, _METHOD_, \ "First input argument, should be if group handle, else if group name")) cdef vector[unsigned int] hList hList=self.hh.getHandlesFromWithinGroupV(groupHandle) return hList ################################################################################## ################################################################################## def close(self, handlePV): cdef str _METHOD_="close" cdef unsigned int handle=0 if isinstance(handlePV, (int,long)) == 1: handle=handlePV elif isinstance(handlePV, (str)) == 1: handle=self.checkForHandle(handlePV) else: raise Exception("{} {} {}".format(self.exString, _METHOD_, \ "First input argument, should be if handle, else if PV")) cdef int stat with nogil: stat=self._c_cafe.close(handle) return stat ################################################################################## def closeChannels(self): cdef int stat with nogil: stat=self._c_cafe.closeChannels() return stat ################################################################################## def closeHandles(self, list handleList): cdef str _METHOD_="closeHandlesV" if isinstance(handleList[0], (str)): handleList=self.checkForHandleList(handleList, force=False) elif not isinstance(handleList[0], (int, long)): raise Exception("{} {} {}".format(self.exString, _METHOD_, \ "First input argument, should be a 'list' of if handles or if PVs")) #Do this only to avoid compiler warnings cdef vector[unsigned int] v for i in range(0, len(handleList)): v.push_back(handleList[i]) cdef int stat with nogil: stat=self._c_cafe.closeHandlesV(v) return stat ################################################################################## def closeDisconnectedChannelsWithinGroup(self, ghandleName): cdef str _METHOD_="closeDisconnectedChannelsWithinGroup" cdef vector[unsigned int] hList cdef vector[unsigned int] disHandles if isinstance(ghandleName, (list)) == 1: for i in range (0, len(ghandleName)): if isinstance(ghandleName[i], (int,long)) == 1: hList.push_back(ghandleName[i]) elif isinstance(ghandleName[i], (str)) == 1: hList.push_back(self.checkForGroupHandle(ghandleName[i])) else: raise Exception("{} {} {}".format(self.exString, _METHOD_, \ "List input arguments, should be if group handle, else if group name")) elif isinstance(ghandleName, (int,long)) == 1: hList.push_back(ghandleName) elif isinstance(ghandleName, (str)) == 1: hList.push_back(self.checkForGroupHandle(ghandleName)) else: raise Exception("{} {} {}".format(self.exString, _METHOD_, \ "First input argument (if not list), should be if group handle, else if group name")) for i in range (0, len(hList)): with nogil: self._c_cafe.closeDisconnectedChannelsFromWithinGroupV(hList[i]) return ################################################################################## def closeChannelKeepHandle(self, handlePV): cdef str _METHOD_="closeChannelKeepHandle" cdef vector[unsigned int] hList cdef int statusClose if isinstance(handlePV, (list)) == 1: for i in range (0, len(handlePV)): if isinstance(handlePV[i], (int,long)) == 1: hList.push_back(handlePV[i]) elif isinstance(handlePV[i], (str)) == 1: hList.push_back(self.checkForHandle(handlePV[i])) else: raise Exception("{} {} {}".format(self.exString, _METHOD_, \ "List input arguments, should be if group handle, else if group name")) elif isinstance(handlePV, (int,long)) == 1: hList.push_back(handlePV) elif isinstance(handlePV, (str)) == 1: hList.push_back(self.checkForHandle(handlePV)) else: raise Exception("{} {} {}".format(self.exString, _METHOD_, \ "First input argument (if not list), should be if handle, else if PV")) with nogil: statusClose= self._c_cafe.closeChannelsKeepHandles(hList) return statusClose ################################################################################## def allConnected(self): return self._c_cafe.allChannelsConnected() ################################################################################## def isConnected(self, handlePV): cdef str _METHOD_="isConnected" cdef unsigned int handle=0 if isinstance(handlePV, (int,long)) == 1: handle=handlePV elif isinstance(handlePV, (str)) == 1: handle=self.checkForHandle(handlePV) else: raise Exception("{} {} {}".format(self.exString, _METHOD_, \ "First input argument, should be if handle, else if PV")) return self._c_cafe.isChannelConnected(handle) ################################################################################## def printDisconnected(self): return self._c_cafe.printDisconnectedHandles() def printDisconnectedHandles(self): return self._c_cafe.printDisconnectedHandles() ################################################################################## def printHandles(self): return self._c_cafe.printHandles() ################################################################################## def printHandle(self, handlePV): cdef str _METHOD_="printHandle" cdef unsigned int handle=0 if isinstance(handlePV, (int,long)) == 1: handle=handlePV elif isinstance(handlePV, (str)) == 1: handle=self.checkForHandle(handlePV) else: raise Exception("{} {} {}".format(self.exString, _METHOD_, \ "First input argument, should be if handle, else if PV")) return self._c_cafe.printHandle(handle) ################################################################################## ################################################################################## def printHandlesV(self, list handleList): cdef str _METHOD_="printHandlesV" if isinstance(handleList[0], (str)): handleList=self.checkForHandleList(handleList) elif not isinstance(handleList[0], (int, long)): raise Exception("{} {} {}".format(self.exString, _METHOD_, \ "First input argument, should be a 'list' of if handles or if PVs")) #Do this only to avoid compiler warnings cdef vector[unsigned int] v for i in range(0, len(handleList)): v.push_back(handleList[i]) return self.hh.printHandlesV(v) ################################################################################## ################################################################################## def getDisconnectedHandles(self): cdef vector[unsigned int] dhV cdef vector[string] pvV self.hh.getDisconnectedHandles(dhV,pvV) return dhV,pvV ################################################################################## ################################################################################## def getHandles(self): cdef vector[unsigned int] dhV cdef vector[string] pvV self.hh.getHandles(dhV,pvV) return dhV,pvV ################################################################################## ################################################################################## def getHandleStates(self): cdef vector[unsigned int] dhV cdef vector[string] pvV cdef vector[unsigned short] stateV self.hh.getHandleStates(dhV,pvV, stateV) return dhV,pvV,stateV ################################################################################## ################################################################################## def getStatusSeverity(self, int statusCode): return self._c_cafe.getCafeStatusSeverity().message(statusCode) ################################################################################## def getStatusCodeAsText(self, int statusCode): return self.cs.code(statusCode) ################################################################################## def getStatusCodeAsString(self, int statusCode): return self.cs.code(statusCode) ################################################################################## def getStatusInfo(self, int statusCode): return self.cs.info(statusCode) ################################################################################## def getStatusMsg(self, int statusCode): return self.cs.message(statusCode) ################################################################################## def getStatus(self, handlePV): cdef str _METHOD_="getStatus" cdef unsigned int handle=0 if isinstance(handlePV, (int,long)) == 1: handle=handlePV elif isinstance(handlePV, (str)) == 1: handle=self.checkForHandle(handlePV) else: raise Exception("{} {} {}".format(self.exString, _METHOD_, \ "First input argument, should be if handle, else if PV")) return self.hh.getStatus(handle) ################################################################################## def getAlarmStatusSeverity(self,handlePV): cdef str _METHOD_="getAlarmStatusSeverity" cdef unsigned int handle=0 if isinstance(handlePV, (int,long)) == 1: handle=handlePV elif isinstance(handlePV, (str)) == 1: handle=self.checkForHandle(handlePV) else: raise Exception("{} {} {}".format(self.exString, _METHOD_, \ "First input argument, should be if handle, else if PV")) cdef short aStatSev[2] status=self.hh.getAlarmStatusSeverity(handle,aStatSev) return aStatSev[0], aStatSev[1] ################################################################################## def getTimeStamp(self,handlePV): cdef str _METHOD_="getTimeStamp" cdef unsigned int handle=0 if isinstance(handlePV, (int,long)) == 1: handle=handlePV elif isinstance(handlePV, (str)) == 1: handle=self.checkForHandle(handlePV) else: raise Exception("{} {} {}".format(self.exString, _METHOD_, \ "First input argument, should be if handle, else if PV")) cdef HandleHelper hh hh._etsNorm=self.hh.getEpicsTimeStampAsUInt32(handle) cpdef ll=[] ll.append(hh._etsNorm.secPastEpoch) ll.append(hh._etsNorm.nsec) #print ("TimeStamp ", ll) return ll ################################################################################## def getTimeStampAsDate(self,handlePV): cdef str _METHOD_="getimeStampAsDate" cdef unsigned int handle=0 if isinstance(handlePV, (int,long)) == 1: handle=handlePV elif isinstance(handlePV, (str)) == 1: handle=self.checkForHandle(handlePV) else: raise Exception("{} {} {}".format(self.exString, _METHOD_, \ "First input argument, should be if handle, else if PV")) cdef HandleHelper hh cpdef ld=[] hh._etsDate =self.hh.getEpicsTimeStampAsDate(handle) ld.append(hh._etsDate.year ) ld.append(hh._etsDate.mon ) ld.append(hh._etsDate.day ) ld.append(hh._etsDate.hour ) ld.append(hh._etsDate.min ) ld.append(hh._etsDate.sec ) ld.append(hh._etsDate.nsec ) #print ("TimeStampAsDate ", ld) return ld ################################################################################## ### Allow user to choose whether or not to open ##### cpdef checkForHandle(self, str pv, bint force=True): cdef unsigned int _handle=0; _handle=self.hh.getHandleFromPV(pv) if _handle == 0: if (force): return self.open(pv) else: return 0 else: return _handle ################################################################################## ################################################################################## cpdef checkForHandleList(self, list pvList, bint force=True): cdef unsigned int nToOpen=0 handleList=[] cdef unsigned int _handle=0 for i in range(0, len(pvList)): _handle=self.hh.getHandleFromPV(pvList[i]) if _handle == 0: if (force): nToOpen=nToOpen+1; self.openNoWait() _handle=self.open(pvList[i]) handleList.append(_handle) else: handleList.append(_handle) if nToOpen > 0: self.openNowAndWait(2.0+nToOpen*0.001) return handleList ################################################################################## ################################################################################## cpdef checkForGroupHandle(self, str gName, bint force=True): cdef unsigned int _ghandle=0; _ghandle=self.hh.getGroupHandleFromGroupName(gName) if _ghandle == 0: if (force): return self.groupOpen(gName) else: return 0 else: return _ghandle ################################################################################## ################################################################################## def getPVNameFromHandle(self, int h): return self._c_cafe.getPVFromHandle(h) ################################################################################## ################################################################################## def getHandleFromPVName(self, str name): #if type(name) is unicode: # py_string = (name).encode('UTF-8') # return self._c_cafe.getHandleFromPV(py_string) return self._c_cafe.getHandleFromPV(name) ################################################################################## ################################################################################## def getChannelInfo(self, handlePV): cdef str _METHOD_="getChannelInfo" cdef unsigned int handle=0 if isinstance(handlePV, (int,long)): handle=handlePV elif isinstance(handlePV, (str)): handle=self.checkForHandle(handlePV, force=True) else: raise Exception("{} {} {}".format(self.exString, _METHOD_, \ "First input argument should be if handle, else if PV")) if handle == 0: if PYCAFE_PRINT_LEVEL>=PYCAFE_PRINT_LOW: self._c_cafe.printStatusMessage(ECAFE_INVALID_HANDLE) raise Exception("EXCEPTION RAISED in PyCafe def getChannelInfo") cdef ChannelRegalia cr status=self._c_cafe.getChannelInfo(handle,cr) if status !=ICAFE_NORMAL: if PYCAFE_PRINT_LEVEL>=PYCAFE_PRINT_LOW: self._c_cafe.printStatusMessage(status) raise Exception("EXCEPTION RAISED in PyCafe def getChannelInfo. Status = %d" %status) #cdef channelInfo ci=channelRegaliaToStruct(cr) #ci.channelID=self._c_cafe.getChannelIDAsString(cr.getChannelID()) #do hex(cr.getChannelID()) to get channelId in hex form return channelRegaliaToStruct(cr) ################################################################################## def getChannelList(self, list listStrings): return self._c_cafe.getFromGlobalChannelList(listStrings) ################################################################################## ################################################################################## def getWFAsString(self, handlePV, bint cache=False): cdef str _METHOD_="getWFAsString" cdef unsigned int handle=0 if isinstance(handlePV, (int,long)) == 1: handle=handlePV elif isinstance(handlePV, (str)) == 1: handle=self.checkForHandle(handlePV) else: raise Exception("{} {} {}".format(self.exString, _METHOD_, \ "First input argument should be if handle, else if PV")) cdef string strWF if (cache == True): status=self._c_cafe.getWFAsStringCache(handle, strWF) else: with nogil: status=self._c_cafe.getWFAsString(handle, strWF) if status !=ICAFE_NORMAL: if PYCAFE_PRINT_LEVEL>=PYCAFE_PRINT_LOW: self._c_cafe.printStatusMessage(status) raise Exception("EXCEPTION RAISED in PyCafe def %s. Status = %d" %_METHOD_,status) return strWF ################################################################################## ################################################################################## def getWFAsStringCache(self, handlePV): return self.getWFAsString(handlePV, cache=True) ################################################################################## ################################################################################## def getEnumFromString(self, handlePV, str enumString): cdef str _METHOD_="getEnumFromString" cdef unsigned int handle=0 if isinstance(handlePV, (int,long)) == 1: handle=handlePV elif isinstance(handlePV, (str)) == 1: handle=self.checkForHandle(handlePV) else: raise Exception("{} {} {}".format(self.exString, _METHOD_, \ "First input argument should be if handle, else if PV")) enumValue=self.hh.getEnumFromString(handle, enumString) if enumValue == -1: raise Exception("{} {} {} {} {}".format(self.exString, _METHOD_, \ ": ENUM string value:", enumString, "not recognized! ")) return enumValue ################################################################################## def getStringFromEnum(self, handlePV, int enumValue): cdef str _METHOD_="getStringFromEnum" cdef unsigned int handle=0 if isinstance(handlePV, (int,long)) == 1: handle=handlePV elif isinstance(handlePV, (str)) == 1: handle=self.checkForHandle(handlePV) else: raise Exception("{} {} {}".format(self.exString, _METHOD_, \ "First input argument should be if handle, else if PV")) return self.hh.getStringFromEnum(handle, enumValue) ################################################################################## def loadSFGroups(self): cdef bytes py_string py_string = ('VA').encode('UTF-8') #cdef vector[string] gnV #gnV.push_back(py_string) #return self._c_cafe.loadSFGroups(gnV[0]) return self._c_cafe.loadSFGroups(py_string) def loadSFGroupsWithBase(self, str VA): cdef bytes py_string py_string = (VA).encode('UTF-8') return self._c_cafe.loadSFGroups(py_string) #return self._c_cafe.loadSFGroups(VA) ################################################################################## def setDbrBase(self, handlePV, DBR_TYPE dbrBase): cdef str _METHOD_="setDbrBase" cdef unsigned int handle=0 if isinstance(handlePV, (int,long)) == 1: handle=handlePV elif isinstance(handlePV, (str)) == 1: handle=self.checkForHandle(handlePV) else: raise Exception("{} {} {}".format(self.exString, _METHOD_, \ "First input argument should be if handle, else if PV")) #Print Warning Message if dbrBase > DBR_TIME: print ("WARNING: PyCafe def setDbrBase(handle/PV, DBR_TYPE)") print ("Allowed DBR_TYPEs are DBR_PLAIN (0), DBR_STS(1), DBR_TIME(2)") print ("The value entered was", dbrBase, "hence assuming DBR_TIME" ) dbrBase=DBR_TIME return self.hh.setCafeDbrType(handle, dbrBase) ################################################################################## ################################################################################## def getDbrBase(self, handlePV): cdef str _METHOD_="getDbrBase" cdef unsigned int handle=0 if isinstance(handlePV, (int,long)) == 1: handle=handlePV elif isinstance(handlePV, (str)) == 1: handle=self.checkForHandle(handlePV) else: raise Exception("{} {} {}".format(self.exString, _METHOD_, \ "First input argument, should be if handle, else if PV")) cdef DBR_TYPE _cafeDbrType=DBR_PLAIN cdef int status=self.hh.getCafeDbrType(handle,_cafeDbrType) return _cafeDbrType ################################################################################## ################################################################################## def setGetCacheWaitPolicy(self, handlePV, ChannelGetCacheWaitPolicyKind wpk): cdef str _METHOD_="setGetCacheWaitPolicy" cdef unsigned int handle=0 if isinstance(handlePV, (int,long)) == 1: handle=handlePV elif isinstance(handlePV, (str)) == 1: handle=self.checkForHandle(handlePV) else: raise Exception("{} {} {}".format(self.exString, _METHOD_, \ "First input argument should be if handle, else if PV")) #Print Warning Message if wpk > GET_CACHE_WAIT: print ("WARNING: PyCafe def setGetCacheWaitPolicy(handle/PV, ChannelGetCacheWaitPolicyKind)") print ("Allowed ChannelGetCacheWaitPolicyKind are GET_CACHE_NO_CHECK (0), GET_CACHE_NO_WAIT (1), GET_CACHE_WAIT (2)") print ("The value entered was", wpk, "hence assuming default value GET_CACHE_WAIT" ) wpk=GET_CACHE_WAIT cdef ChannelGetCacheWaitPolicy channelGetCacheWaitPolicy channelGetCacheWaitPolicy.setWaitKind(wpk) return self.ph.setChannelGetCacheWaitPolicy(handle,channelGetCacheWaitPolicy) ################################################################################## ################################################################################## def setGetCacheWaitPolicyAllHandles(self, ChannelGetCacheWaitPolicyKind wpk): #Print Warning Message if wpk > GET_CACHE_WAIT: print ("WARNING: PyCafe def setGetCacheWaitPolicyAllHandles(ChannelGetCacheWaitPolicyKind)") print ("Allowed ChannelGetCacheWaitPolicyKind are GET_CACHE_NO_CHECK (0), GET_CACHE_NO_WAIT (1), GET_CACHE_WAIT (2)") print ("The value entered was", wpk, "hence assuming default value GET_CACHE_WAIT" ) wpk=GET_CACHE_WAIT cdef ChannelGetCacheWaitPolicy channelGetCacheWaitPolicy channelGetCacheWaitPolicy.setWaitKind(wpk) return self.ph.setChannelGetCacheWaitPolicyAllHandles(channelGetCacheWaitPolicy) ################################################################################## ################################################################################## def setGetActionWhenMonitorPolicy(self, handlePV, ChannelGetActionWhenMonitorPolicyKind wmpk): cdef str _METHOD_="setGetActionWhenMonitorPolicy" cdef unsigned int handle=0 if isinstance(handlePV, (int,long)) == 1: handle=handlePV elif isinstance(handlePV, (str)) == 1: handle=self.checkForHandle(handlePV) else: raise Exception("{} {} {}".format(self.exString, _METHOD_, \ "First input argument should be if handle, else if PV")) #Print Warning Message if wmpk > GET_FROM_IOC: print ("WARNING: PyCafe def setGetActionWhenMonitorPolicy(handle/PV, ChannelGetActionWhenMonitorPolicyKind)") print ("Allowed ChannelGetActionWhenMonitorPolicyKind are GET_FROM_CACHE (0), GET_FROM_IOC (1)") print ("The value entered was", wmpk, "hence assuming default value GET_FROM_IOC" ) wmpk=GET_FROM_IOC cdef ChannelGetActionWhenMonitorPolicy channelGetActionWhenMonitorPolicy channelGetActionWhenMonitorPolicy.setActionKind(wmpk) return self.ph.setChannelGetActionWhenMonitorPolicy(handle,channelGetActionWhenMonitorPolicy) ################################################################################## ################################################################################## def setGetActionWhenMonitorPolicyAllHandles(self, ChannelGetActionWhenMonitorPolicyKind wmpk): #Print Warning Message if wmpk > GET_FROM_IOC: print ("WARNING: PyCafe def setGetActionWhenMonitorPolicyAllHandles(ChannelGetActionWhenMonitorPolicyKind)") print ("Allowed ChannelGetActionWhenMonitorPolicyKind are GET_FROM_CACHE (0), GET_FROM_IOC (1)") print ("The value entered was", wmpk, "hence assuming default value GET_FROM_IOC" ) wmpk=GET_FROM_IOC cdef ChannelGetActionWhenMonitorPolicy channelGetActionWhenMonitorPolicy channelGetActionWhenMonitorPolicy.setActionKind(wmpk) return self.ph.setChannelGetActionWhenMonitorPolicyAllHandles(channelGetActionWhenMonitorPolicy) ################################################################################## ################################################################################## def getNonBlocking(self, handlePV): ################################################################################## cdef str _METHOD_="getNonBlocking" cdef unsigned int handle=0 cdef int status if isinstance(handlePV, (int,long)) == 1: handle=handlePV elif isinstance(handlePV, (str)) == 1: handle=self.checkForHandle(handlePV) else: raise Exception("{} {} {}".format(self.exString, _METHOD_, \ "First input argument should be if handle, else if PV")) with nogil: status=self._c_cafe.getNonBlocking(handle) if status != ICAFE_NORMAL: if PYCAFE_PRINT_LEVEL>=PYCAFE_PRINT_LOW: if handle == 0: self._c_cafe.printStatusMessage(status) else: self._c_cafe.printStatus(handle, status) if self.haveExceptions: raise Exception("EXCEPTION RAISED in PyCafe def getNonBlocking. Status = %d" %status) return status ################################################################################## ################################################################################## def getStr(self, handlePV, object cb=None): return self.get(handlePV,dt='str') ################################################################################## ################################################################################## def getInt(self, handlePV, object cb=None): return self.get(handlePV, dt='int') ################################################################################## ################################################################################## def getFloat(self, handlePV, object cb=None): return self.get(handlePV, dt='float') ################################################################################## ################################################################################## def get(self, handlePV, str dt='native'): ################################################################################## cdef str _METHOD_ = "get" cdef unsigned int handle=0 if isinstance(handlePV, (int,long)) == 1: handle=handlePV elif isinstance(handlePV, (str)) == 1: handle=self.checkForHandle(handlePV) else: raise Exception("{} {} {}".format(self.exString, _METHOD_, \ "First input argument should be if handle, else if PV")) cdef int status cdef long dtr=0 status=self.hh.getDataTypeNative(handle, dtr) if status != ICAFE_NORMAL: if PYCAFE_PRINT_LEVEL>=PYCAFE_PRINT_LOW: if handle == 0: self._c_cafe.printStatusMessage(status) else: self._c_cafe.printStatus(handle, status) if self.haveExceptions: _cyCafeException = CyCafeException(_type='cafe', _source=_METHOD_,_handle=handle, _pv=self._c_cafe.getPVFromHandle(handle), \ _ec=status, _et=self.cs.code(status), _ei=self.cs.info(status)) raise Exception(_cyCafeException) return None elif dtr in [CAFE_NO_ACCESS, CAFE_TYPENOTCONN]: if self._c_cafe.isChannelConnected(handle) is False: self._c_cafe.getChannelInfo(handle,self.channelInfo) if PYCAFE_PRINT_LEVEL>=PYCAFE_PRINT_LOW: self._c_cafe.printStatus(handle,self.channelInfo.getCafeConnectionState() ) if self.haveExceptions: #raise Exception("EXCEPTION RAISED in PyCafe def get. \ #Channel Not Connected, status = %d" %self.channelInfo.getCafeConnectionState()) _cyCafeException = CyCafeException(_type='cafe',_source=_METHOD_,_handle=handle, _pv=self._c_cafe.getPVFromHandle(handle), \ _ec=self.channelInfo.getCafeConnectionState(), \ _et=self.cs.code(self.channelInfo.getCafeConnectionState()), \ _ei=self.cs.info(self.channelInfo.getCafeConnectionState())) raise Exception(_cyCafeException) return None #Likely to be superfluous if PYCAFE_PRINT_LEVEL>=PYCAFE_PRINT_LOW: self._c_cafe.printStatus(handle,ICAFE_TYPENOTCONN) if self.haveExceptions: _cyCafeException = CyCafeException(type='cafe', _source=_METHOD_,_handle=handle, _pv=self._c_cafe.getPVFromHandle(handle), \ _ec=ICAFE_TYPENOTCONN, _et=self.cs.code(ICAFE_TYPENOTCONN), _ei=self.cs.info(ICAFE_TYPENOTCONN)) raise Exception(_cyCafeException) return None #global py_cb_handle_get #if cb: #py_cb_handle_get=cb #self.setChannelRequestPolicyGet(handle, wait=WAIT, when=FLUSH_NOW, method=WITH_CALLBACK_USER_SUPPLIED, pcb=True) cdef unsigned int dtcheck = dtr dtcheck=getMatchedDataType(dt, dtr) if dtcheck in [CAFE_STRING]: with nogil: status=self._c_cafe.getString(handle, self.valStr) if status==ICAFE_NORMAL: return self.valStr elif dtcheck in [CAFE_SHORT, CAFE_CHAR, CAFE_LONG]: with nogil: status=self._c_cafe.getLong(handle, self.valInt) if status==ICAFE_NORMAL: return self.valInt elif dtcheck in [CAFE_FLOAT, CAFE_DOUBLE]: with nogil: status=self._c_cafe.getDouble(handle, self.valFloat) if status==ICAFE_NORMAL: return self.valFloat elif dtcheck==CAFE_ENUM: #if enum, string taken as native if self._c_cafe.isEnum(handle): with nogil: status=self._c_cafe.getString(handle, self.valStr) if status==ICAFE_NORMAL: return self.valStr else: with nogil: status=self._c_cafe.getLong(handle, self.valInt) if status ==ICAFE_NORMAL: return self.valInt else: print ("This line in PyCafe def get should never appear!") return None if status !=ICAFE_NORMAL: if PYCAFE_PRINT_LEVEL>=PYCAFE_PRINT_LOW: if handle == 0: self._c_cafe.printStatusMessage(status) else: self._c_cafe.printStatus(handle, status) if self.haveExceptions: _cyCafeException = CyCafeException(_type='cafe',_source=_METHOD_,_handle=handle, _pv=self._c_cafe.getPVFromHandle(handle), \ _ec=status, _et=self.cs.code(status), _ei=self.cs.info(status)) raise Exception(_cyCafeException) return None ################################################################################## #END: def get(self, handlePV, dt) ################################################################################## ################################################################################## def getIntList(self, handlePV): return self.getList(handlePV, 'int') ################################################################################## def getFloatList(self, handlePV): return self.getList(handlePV, 'float') ################################################################################## def getStrList(self, handlePV): return self.getList(handlePV, 'str') ################################################################################## def getList(self, handlePV, str dt='native'): cdef str _METHOD_="getList(handlePV, str dt='native')" cdef unsigned int handle=0 if isinstance(handlePV, (int,long)) == 1: handle=handlePV elif isinstance(handlePV, (str)) == 1: handle=self.checkForHandle(handlePV) else: raise Exception("{} {} {}".format(self.exString, _METHOD_, \ "First input argument should be if handle, else if PV")) cdef int status cdef long dtr=0 status=self.hh.getDataTypeNative(handle, dtr) if status != ICAFE_NORMAL: if PYCAFE_PRINT_LEVEL>=PYCAFE_PRINT_LOW: if handle == 0: self._c_cafe.printStatusMessage(status) else: self._c_cafe.printStatus(handle, status) if self.haveExceptions: _cyCafeException = CyCafeException(_type='cafe',_source=_METHOD_,_handle=handle, _pv=self._c_cafe.getPVFromHandle(handle), \ _ec=status, _et=self.cs.code(status), _ei=self.cs.info(status)) raise Exception(_cyCafeException) return [None] elif dtr in [CAFE_NO_ACCESS, CAFE_TYPENOTCONN]: if self._c_cafe.isChannelConnected(handle) is False: self._c_cafe.getChannelInfo(handle,self.channelInfo) if PYCAFE_PRINT_LEVEL>=PYCAFE_PRINT_LOW: self._c_cafe.printStatus(handle,self.channelInfo.getCafeConnectionState() ) if self.haveExceptions: _cyCafeException = CyCafeException(_type='cafe',_source=_METHOD_,_handle=handle, _pv=self._c_cafe.getPVFromHandle(handle), \ _ec=self.channelInfo.getCafeConnectionState(), _et=self.cs.code(self.channelInfo.getCafeConnectionState()),\ _ei=self.cs.info(self.channelInfo.getCafeConnectionState())) raise Exception(_cyCafeException) return [None] #This paragraph should be superfluous if PYCAFE_PRINT_LEVEL>=PYCAFE_PRINT_LOW: self._c_cafe.printStatus(handle,ICAFE_TYPENOTCONN) if self.haveExceptions: _cyCafeException = CyCafeException(_type='cafe',_source=_METHOD_,_handle=handle, _pv=self._c_cafe.getPVFromHandle(handle), \ _ec=ICAFE_TYPENOTCONN, _et=self.cs.code(ICAFE_TYPENOTCONN), _ei=self.cs.info(ICAFE_TYPENOTCONN)) raise Exception(_cyCafeException) return [None] cdef unsigned int dtcheck = dtr dtcheck=getMatchedDataType(dt, dtr) #print ("dtcheck", dtcheck) cdef unsigned int nelemNative =self.hh.getNelemNative (handle) cdef unsigned int nelemClient =self.hh.getNelemClient (handle) cdef unsigned int nelemRequest=self.hh.getNelemRequest(handle) cdef unsigned int nelemMethod = nelemClient cdef dbr_string_t * valStringArray cdef int * valIntArray cdef double * valDoubleArray if dtcheck in [CAFE_STRING]: valStringArray = malloc( nelemMethod * sizeof(dbr_string_t)) with nogil: status=self._c_cafe.getDbrStringArray(handle, valStringArray) ll=[] for i in range(0,nelemMethod): ll.append(valStringArray[i]) free(valStringArray) if status == ICAFE_NORMAL: return ll elif dtcheck in [CAFE_SHORT, CAFE_CHAR, CAFE_LONG]: valIntArray = malloc( nelemMethod * sizeof(int)) with nogil: status=self._c_cafe.getLongArray(handle, valIntArray) ll=[] for i in range(0, nelemMethod): ll.append(valIntArray[i]) free(valIntArray) if status == ICAFE_NORMAL: return ll elif dtcheck in [CAFE_FLOAT, CAFE_DOUBLE]: valDoubleArray = malloc( nelemMethod * sizeof(double)) with nogil: status=self._c_cafe.getDoubleArray(handle, valDoubleArray) ll=[] for i in range(0, nelemMethod): ll.append(valDoubleArray[i]) free(valDoubleArray) if status == ICAFE_NORMAL: return ll elif dtcheck==CAFE_ENUM: #if enum, string taken as native if self._c_cafe.isEnum(handle): valStringArray = malloc( nelemMethod * sizeof(dbr_string_t)) with nogil: status=self._c_cafe.getDbrStringArray(handle, valStringArray) ll=[] for i in range(0,nelemMethod): ll.append(valStringArray[i]) free(valStringArray) if status ==ICAFE_NORMAL: return ll else: valIntArray = malloc( nelemMethod * sizeof(int)) with nogil: status=self._c_cafe.getLongArray(handle, valIntArray) ll=[] for i in range(0,nelemMethod): ll.append(valIntArray[i]) free(valIntArray) if status ==ICAFE_NORMAL: return ll #Will not happen; already covered above elif dtcheck in [CAFE_NO_ACCESS,CAFE_TYPENOTCONN]: print ("Channel", self._c_cafe.getPVFromHandle(handle), " not connected") return None else: print ("This line in PyCafe def getAsList should never appear!") return None if status !=ICAFE_NORMAL: if PYCAFE_PRINT_LEVEL>=PYCAFE_PRINT_LOW: if handle == 0: self._c_cafe.printStatusMessage(status) else: self._c_cafe.printStatus(handle, status) if self.withExceptions is False: _cyCafeException = CyCafeException(_type='cafe',_source=_METHOD_,_handle=handle, _pv=self._c_cafe.getPVFromHandle(handle), \ _ec=status, _et=self.cs.code(status), _ei=self.cs.info(status)) raise Exception(_cyCafeException) return None ################################################################################## def getStrArray(self, handlePV, str art='memoryview'): return self.getArray(handlePV, dt='str', art=art) ################################################################################## ################################################################################## def getIntArray(self, handlePV, str art='memoryview' ): return self.getArray(handlePV, dt='int', art=art) ################################################################################## ################################################################################## def getFloatArray(self, handlePV, str art='memoryview'): return self.getArray(handlePV, dt='float', art=art ) ################################################################################## ################################################################################## def getArray(self, handlePV, str dt='native', str art='memoryview'): ################################################################################## #Typed Memoryviews from K.W. Smith #Cython has a C-level type the typed memoryview, that conceptually overlaps #with the Python memoryiew and expands on it. A typed memory view is used to #view (share) data from a buffer-producing object. #A typed memoryview has a memory-view like interface and is easier to use than #working with C-level buffers directly. And because a typed memoryview is designed #to work with the buffer protocol it supports any buffer-producing object efficiently #allowing sharing of data buffers without copying #If we declare a typed memoryview with a single colon in each dimension's slot, #the typed mv can acquire a buffer from an object if the same dimensionality and with #either strided or contiguous packing. #Declaring a C-contiguous typed memoryview: all dimensions except the last is specified #with two colons followed by a literal 1. The mnemonic is that the last dimension has #a unitary stride, i.e., is contiguous in memory, hence C contiguous cdef str _METHOD_="getArray" cdef unsigned int handle=0 if isinstance(handlePV, (int,long)) == 1: handle=handlePV elif isinstance(handlePV, (str)) == 1: handle=self.checkForHandle(handlePV) else: raise Exception("{} {} {}".format(self.exString, _METHOD_, \ "First input argument should be if handle, else if PV")) cdef: short * i16val int * ival double * dval float * fval dbr_string_t * sval cnp.int16_t [::1] mvShort #C-contiguous int [::1] mvInt #C-contiguous double [::1] mvDouble #C-contiguous float [::1] mvFloat #C-contiguous #str [:,::1] mvStr cnp.ndarray arr long dtr=0 int status #cvarray mvDoubleArray unsigned int i unsigned int ij array.array a cnp.uint8_t [::1] mvUInt8 #C-contiguous cnp.int8_t [::1] mvInt8 #C-contiguous cnp.uint16_t [::1] mvUInt16 #C-contiguous cnp.int16_t [::1] mvInt16 #C-contiguous cnp.uint32_t [::1] mvUInt32 #C-contiguous cnp.int32_t [::1] mvInt32 #C-contiguous cnp.uint64_t [::1] mvUInt64 #C-contiguous cnp.int64_t [::1] mvInt64 #C-contiguous #cnp.float16_t [::1] mvFloat16 #C-contiguous cnp.float32_t [::1] mvFloat32 #C-contiguous cnp.float64_t [::1] mvFloat64 #C-contiguous #cdef PVDataHolder pvd status=self.hh.getDataTypeNative(handle, dtr) if status != ICAFE_NORMAL: if PYCAFE_PRINT_LEVEL>=PYCAFE_PRINT_LOW: if handle == 0: self._c_cafe.printStatusMessage(status) else: self._c_cafe.printStatus(handle, status) if self.haveExceptions: _cyCafeException = CyCafeException(_type='cafe',_source=_METHOD_,_handle=handle, _pv=self._c_cafe.getPVFromHandle(handle), \ _ec=status, _et=self.cs.code(status), _ei=self.cs.info(status)) raise Exception(_cyCafeException) return [None] elif dtr in [CAFE_NO_ACCESS, CAFE_TYPENOTCONN]: if self._c_cafe.isChannelConnected(handle) is False: self._c_cafe.getChannelInfo(handle,self.channelInfo) if PYCAFE_PRINT_LEVEL>=PYCAFE_PRINT_LOW: self._c_cafe.printStatus(handle,self.channelInfo.getCafeConnectionState() ) if self.haveExceptions: _cyCafeException = CyCafeException(_type='cafe',_source=_METHOD_,_handle=handle, _pv=self._c_cafe.getPVFromHandle(handle), \ _ec=self.channelInfo.getCafeConnectionState(), _et=self.cs.code(self.channelInfo.getCafeConnectionState()),\ _ei=self.cs.info(self.channelInfo.getCafeConnectionState())) raise Exception(_cyCafeException) return [None] #Likely to be superfluous if PYCAFE_PRINT_LEVEL>=PYCAFE_PRINT_LOW: self._c_cafe.printStatus(handle,ICAFE_TYPENOTCONN) if self.haveExceptions: _cyCafeException = CyCafeException(_type='cafe',_source=_METHOD_,_handle=handle, _pv=self._c_cafe.getPVFromHandle(handle), \ _ec=ICAFE_TYPENOTCONN, _et=self.cs.code(ICAFE_TYPENOTCONN), _ei=self.cs.info(ICAFE_TYPENOTCONN)) raise Exception(_cyCafeException) return [None] cdef unsigned int dtcheck = dtr dtcheck=getMatchedDataType(dt, dtr) cdef unsigned int nelemNative = self.hh.getNelemNative (handle) cdef unsigned int nelemClient = self.hh.getNelemClient (handle) cdef unsigned int nelemRequest = self.hh.getNelemRequest(handle) cdef unsigned int nelemMethod = nelemClient cdef unsigned int nelemMemory = nelemClient #previously nelemNative - has to be at least size of nelemClient #print('native', self.hh.getNelemNative(handle)) #print('client', self.hh.getNelemClient(handle)) #print('request',self.hh.getNelemRequest(handle)) #print ('dtcheck', dtcheck) #cdef double [::1] cyarr_view #The element type of a typed memoryview may be a numeric scalar type (int, float) #It may be a ctypedef alias, or it may be a structured type declared with e.g. cdef struct if dtcheck in [CAFE_STRING, CAFE_ENUM]: sval = malloc( nelemMemory * sizeof(dbr_string_t)) with nogil: status=self._c_cafe.getDbrStringArray(handle, sval) #http://cython.readthedocs.org/en/latest/src/tutorial/numpy.html #Some data types are not yet supported, like boolean arrays and string arrays. locallist=[] if status==ICAFE_NORMAL: if art in ['numpy','ndarray','numpy.ndarray']: ###elif dt in ['np.string','np.str','np.unicode','np.string_','np.str_','np.unicode_']: mvStr = np.empty(nelemMethod, dtype=(np.str_,40)) #mvStr=np.array(self.hh.getNelemRequest(handle), dtype='S40') for i in range(0, nelemMethod): #print sval[i].decode('utf8'), i mvStr[i]=str(sval[i]) #.decode('utf8') #locallist.append(sval[i]) free(sval) return np.array(mvStr) elif art in ['memoryview','mv','memoryviewslice']: mvStr = np.empty(nelemMethod, dtype=(np.str_,40), order='C') for ij in range(0, nelemMethod): mvStr[ij]=str(sval[ij]) free(sval) return memoryview(mvStr) elif art in ['array','array.array']: print ("PyCafe.pyx getArray, 'array' type does not support array of strings; returning list") #RETURNING LIST - DOES NOT SUPPORT array of strings; #arrayArray=array.array('u', 'hello \u2641') arrayArray=[] for ij in range(0, nelemMethod): arrayArray.append(str(sval[ij])) free(sval) return arrayArray elif art in ['ctypes', 'ctype']: ctypesArray=(ctypes.c_char_p*nelemMethod)() #c_wchar_p is unicode! for ij in range(0, nelemMethod): ctypesArray[ij]=(sval[ij]).encode('utf-8') free(sval) return ctypesArray else: print("Unknown array type in user request for art='",art,"'. Possible types are:") print("memoryview, numpy, array, ctypes") print("Returning memoryview") mvStr = np.empty(nelemMethod, dtype=(np.str_,40), order='C') for ij in range(0, nelemMethod): mvStr[ij]=sval[ij] free(sval) return mvStr elif dtcheck in [CAFE_SHORT, CAFE_CHAR]: i16val = malloc(nelemMemory * sizeof(np.int16)) with nogil: status=self._c_cafe.getShortArray(handle, i16val) if status==ICAFE_NORMAL: #np.empty preferred, else mvInt does not get correct value for first couple of array elements if art in ['numpy','ndarray','numpy.ndarray']: # ##mvInt=ival # ##arr = np.ascontiguousarray(mvInt) # ##set_base(arr, ival) if dt in ['np.short','np.int16','short','int16']: mvShort = np.empty(nelemMethod, dtype=np.int16, order='C') for ij in range(0, nelemMethod): mvShort[ij]=i16val[ij] free(i16val) return np.array(mvShort) elif dt in ['np.int8','np.bool_','np.byte','bool','byte']: mvInt8 = np.empty(nelemMethod, dtype=np.int8, order='C') for ij in range(0, nelemMethod): mvInt8[ij]=i16val[ij] free(i16val) return np.array(mvInt8) elif dt in ['uchar','np.uint8']: mvUInt8 = np.empty(nelemMethod, dtype=np.uint8, order='C') for ij in range(0, nelemMethod): mvUInt8[ij]=i16val[ij] free(i16val) return np.array(mvUInt8) else: mvShort = np.empty(nelemMethod, dtype=np.int16, order='C') #mvShortNP = np.ndarray(buffer=np.array(i16val), dtype=np.int16, order='C') for ij in range(0, nelemMethod): mvShort[ij]=i16val[ij] #mvShortNP=cnp.asarray(i16val) #aaa=np.full(nelemMethod,i16val[ij] free(i16val) return memoryview(mvShort) elif art in ['array','array.array']: a=array.array('h') for ij in range(0, nelemMethod): a.append(i16val[ij]) free(i16val) return a elif art in ['ctypes', 'ctype']: ctypesArray16=(ctypes.c_int16*nelemMethod)() for ij in range(0, nelemMethod): ctypesArray16[ij]=i16val[ij] free(i16val) return ctypesArray16 else: print("Unknow array type in user request for art='",art,"'. Possible types are:") print("memoryview, numpy, array, ctypes") print("Returning memoryview") mvShort = np.empty(nelemMethod, dtype=np.int16, order='C') for ij in range(0, nelemMethod): mvShort[ij]=i16val[ij] free(i16val) return mvShort elif dtcheck in [CAFE_LONG]: ival = malloc( nelemMemory * sizeof(np.int32)) with nogil: status=self._c_cafe.getLongArray(handle, ival) if status==ICAFE_NORMAL: #np.empty preferred, else mvInt does not get correct value for first couple of array elements #nelemMethod=self.hh.getnelemMethod(handle) if art in ['numpy','ndarray','numpy.ndarray']: ##elif dt in ['np.intc','np.int_','np.long','np.ulong','np.ushort','np.int32','np.int64','np.uint32','np.uint64']: if dt in ['np.int32','int32']: mvInt32 = np.empty(nelemMethod, dtype=np.int32, order='C') for ij in range(0, nelemMethod): mvInt32[ij]=ival[ij] free(ival) return np.array(mvInt32) # elif dt in ['np.uint32','uint32']: mvUInt32 = np.empty(nelemMethod, dtype=np.uint32, order='C') for ij in range(0, nelemMethod): mvUInt32[ij]=ival[ij] free(ival) return np.array(mvUInt32) #elif dt in ['np.int64','int64']: # mvInt64 = np.empty(nelemMethod, dtype=np.int64, order='C') # for ij in range(0, nelemMethod): # mvInt64[ij]=ival[ij] # free(ival) # return np.array(mvInt64) # #elif dt in ['np.uint64','uint64']: # mvUInt64 = np.empty(nelemMethod, dtype=np.uint64, order='C') # for ij in range(0, nelemMethod): # mvUInt64[ij]=ival[ij] # free(ival) # return np.array(mvUInt64) else: mvInt = np.empty(nelemMethod, dtype=np.int32, order='C') for ij in range(0, nelemMethod): mvInt[ij]=ival[ij] free(ival) return np.array(mvInt) #arr elif art in ['memoryview','mv','memoryviewslice']: mvInt = np.empty(nelemMethod, dtype=np.int32, order='C') for ij in range(0, nelemMethod): mvInt[ij]=ival[ij] free(ival) return memoryview(mvInt) elif art in ['array','array.array']: a=array.array('h') for ij in range(0, nelemMethod): a.append(ival[ij]) free(ival) return a elif art in ['ctypes', 'ctype']: ctypesArray=(ctypes.c_int32*nelemMethod)() for ij in range(0, nelemMethod): ctypesArray[ij]=ival[ij] free(ival) return ctypesArray else: print("Unknow array type in user request for art='",art,"'. Possible types are:") print("memoryview, numpy, array, ctypes") print("Returning memoryview") mvInt = np.empty(nelemMethod, dtype=np.int32, order='C') for ij in range(0, nelemMethod): mvInt[ij]=ival[ij] free(ival) return mvInt elif dtcheck in [CAFE_FLOAT]: fval = malloc( nelemMemory * sizeof(float)) start=time.time() with nogil: status=self._c_cafe.getFloatArray(handle, fval) # pvd.setNelem(self.hh.getnelemMethod(handle)) # with nogil: # status=self._c_cafe.get(handle, pvd) if status==ICAFE_NORMAL: #nelemMethod=self.hh.getnelemMethod(handle) if art in ['numpy','ndarray','numpy.ndarray']: ##elif dt in ['np.float16','np.float32']: mvFloat = np.empty(nelemMethod, dtype=np.float32) for ij in range(0, nelemMethod): mvFloat[ij]=fval[ij] # pvd.getAsFloat(ij) #arr=np.asarray(mvFloat) free(fval) #arr = np.ascontiguousarray(mvDouble) #set_base(arr, dval) return np.array(mvFloat) #arr elif art in ['memoryview','mv','memoryviewslice']: #Method A to return memory view mvFloat = np.empty(nelemMethod, dtype=np.float32) for ij in range(0, nelemMethod): mvFloat[ij]=fval[ij] free(fval) #memoryview(mvFloat).tolist() #tolist() only supports byte views return memoryview(mvFloat) #Method B to return memory view ''' mvDoubleArray=cvarray(shape=(nelemMethod,), itemsize=sizeof(double), format="d") cyarr_view=mvDoubleArray for i in range(0, nelemMethod): #mvDoubleArray AVOID COPY TO mvDoubel Array!! cyarr_view[i]=dval[i] free(dval) return cyarr_view ''' elif art in ['array','array.array']: a=array.array('f') for ij in range(0, nelemMethod): a.append(fval[ij]) free(fval) return a ''' arrayArray=array.array('f') for ij in range(0, nelemMethod): arrayArray.append(fval[ij]) free(fval) return arrayArray ''' ''' cvFloatArray=cvarray(shape=(nelemMethod,), itemsize=sizeof(float), format="f") cyarr_view=cvFloatArray for i in range(0, nelemMethod): #mvDoubleArray AVOID COPY TO mvDoubel Array!! cyarr_view[i]=fval[i] free(fval) return cyarr_view ''' elif art in ['ctypes', 'ctype']: ctypesArray=(ctypes.c_float*nelemMethod)() for ij in range(0, nelemMethod): ctypesArray[ij]=fval[ij] free(fval) return ctypesArray else: print("Unknow array type in user request for art='",art,"'. Possible types are:") print("memoryview, numpy, array, ctypes") print("Returning memoryview") mvFloat = np.empty(nelemMethod, dtype=np.float32) for ij in range(0, nelemMethod): mvFloat[ij]=fval[ij] free(fval) return mvFloat elif dtcheck in [CAFE_DOUBLE]: #start=time.time() dval = malloc( nelemMemory * sizeof(double)) with nogil: #for ij in range(0, 10000): status=self._c_cafe.getDoubleArray(handle, dval) if status==ICAFE_NORMAL: #nelemMethod=self.hh.getnelemMethod(handle) if art in ['numpy','ndarray','numpy.ndarray']: #elif dt in ['double', 'np.float_','np.float64']: #mvDouble=dval mvDouble = np.empty(nelemMethod, dtype=np.float64) for ij in range(0, nelemMethod): mvDouble[ij]=dval[ij] #arr=np.asarray(mvDouble) free(dval) #end=time.time() #print (end - start) return np.array(mvDouble) #arr elif art in ['memoryview','mv','memoryviewslice']: #Method A to return memory view mvDouble = np.empty(nelemMethod, dtype=np.float64) for ij in range(0, nelemMethod): mvDouble[ij]=dval[ij] free(dval) #end=time.time() #print (end - start) return memoryview(mvDouble) elif art in ['array','array.array']: a=array.array('d') for ij in range(0, nelemMethod): a.append(dval[ij]) free(dval) #end=time.time() #print (end - start) return a elif art in ['ctypes', "ctype"]: ctypesArray=(ctypes.c_double*nelemMethod)() for ij in range(0, nelemMethod): ctypesArray[ij]=dval[ij] free(dval) return ctypesArray else: print("Unknow array type in user request for art='",art,"'. Possible types are:") print("memoryview, numpy, array, ctypes") print("Returning memoryview") mvDouble = np.empty(nelemMethod, dtype=np.float64) for ij in range(0, nelemMethod): mvDouble[ij]=dval[ij] free(dval) return mvDouble if status !=ICAFE_NORMAL: if PYCAFE_PRINT_LEVEL>=PYCAFE_PRINT_LOW: if handle == 0: self._c_cafe.printStatusMessage(status) else: self._c_cafe.printStatus(handle, status) if self.haveExceptions: _cyCafeException = CyCafeException(_type='cafe',_source=_METHOD_,_handle=handle, _pv=self._c_cafe.getPVFromHandle(handle), \ _ec=status, _et=self.cs.code(status), _ei=self.cs.info(status)) raise Exception(_cyCafeException) return [None] ################################################################################## #END: def getArray(self, handlePV, dt): ################################################################################## ################################################################################## def getPVInt(self, handlePV): return self.getPV(handlePV,'int') ################################################################################## ################################################################################## def getPVFloat(self, handlePV): return self.getPV(handlePV,'float') ################################################################################## ################################################################################## def getPVStr(self, handlePV): return self.getPV(handlePV,'str') ################################################################################## ################################################################################## def getPV(self, handlePV, str dt='native'): ################################################################################## cdef str _METHOD_="getPV" cdef unsigned int handle=0 if isinstance(handlePV, (int,long)) == 1: handle=handlePV elif isinstance(handlePV, (str)) == 1: handle=self.checkForHandle(handlePV) else: raise Exception("{} {} {}".format(self.exString, _METHOD_, \ "First input argument should be if handle, else if PV")) cdef int status cdef PVDataHolder pvd = PVDataHolder(self.hh.getNelemNative(handle)) with nogil: status=self._c_cafe.get(handle, pvd) if status !=ICAFE_NORMAL: if PYCAFE_PRINT_LEVEL>=PYCAFE_PRINT_LOW: if handle == 0: self._c_cafe.printStatusMessage(status) else: self._c_cafe.printStatus(handle, status) if self.haveExceptions: _cyCafeException = CyCafeException(_type='cafe',_source=_METHOD_,_handle=handle, _pv=self._c_cafe.getPVFromHandle(handle), \ _ec=status, _et=self.cs.code(status), _ei=self.cs.info(status)) raise Exception(_cyCafeException) pvd_valnone=PVDataHolderToStruct(pvd, dt) pvd_valnone.value[0]=None return pvd_valnone return PVDataHolderToStruct(pvd, dt) ################################################################################## #END def getPV(self, handlePV): ################################################################################## ################################################################################## def getPVStrList(self, handleList): return self.getPVList(handleList, dt='str') ################################################################################## ################################################################################## def getPVIntList(self, handleList): return self.getPVList(handleList, dt='int') ################################################################################## ################################################################################## def getPVFloatList(self, handleList): return self.getPVList(handleList, dt='float') ################################################################################## ################################################################################## def getPVList(self, handleList, str dt='native', cacheFlag=False): ################################################################################## cdef str _METHOD_="getPVList" if isinstance(handleList, (str,int,long)): hl=[] hl.append(handleList) handleList=[] handleList=hl if isinstance(handleList[0], (str)): handleList=self.checkForHandleList(handleList) elif not isinstance(handleList[0], (int, long)): raise Exception("{} {} {}".format(self.exString, _METHOD_, \ "First input argument should be a 'list' of if handles, else if PVs")) #cdef unsigned int nelemTotal=0 #for i in range(0, len(handleList)): # nelemTotal+=self.hh.getNelemNative(handleList[i]) # cdef int size_cdu = sizeof(CAFE_DATATYPE_UNION) #16 is size of boost_shared_ptr (size 40) # cdef PVDataHolder * pvd = \ # malloc( 100000000 + \ # len(handleList) * sizeof(PVDataHolder) + nelemTotal*size_cdu) cdef vector[unsigned int] v #do this to avoid compiler warning messages for i in range(0, len(handleList)): v.push_back(handleList[i]) cdef PVDataHolder * pvd = self._c_cafe.getPVData(v) for i in range(0, len(handleList)): pvd[i].setNelem(self.hh.getNelemNative(handleList[i])) #print " ", pvd[i].getNelem(), self.hh.getNelemNative(handleList[i]), i cdef int status if(cacheFlag): status=self._c_cafe.getCachePVArray(v, pvd) else: with nogil: status=self._c_cafe.getPVArray(v, pvd) if status !=ICAFE_NORMAL: if PYCAFE_PRINT_LEVEL>=PYCAFE_PRINT_LOW: self._c_cafe.printStatusMessage(status) for i in range(0, len(handleList)): if (pvd[i].getStatus() != ICAFE_NORMAL): print ("Handle=", handleList[i], "PV=", self.hh.getPVFromHandle(handleList[i]) ) print ("with error status=", pvd[i].getStatus() ) self._c_cafe.printStatusMessage(status) print ("") #raise Exception("EXCEPTION RAISED in PyCafe def getPVList. Status = %d" %status) cdef unsigned int dtn cdef unsigned int dtcheck pvdList=[] cpdef pvdata p1 for i in range(0, len(handleList)): dtn = pvd[i].getDataType(); dtcheck=getMatchedDataType(dt, dtn) localList=[] if pvd[i].getNelem() == 1: if dtcheck==CAFE_STRING: localList.append(pvd[i].getAsString()) elif dtcheck==CAFE_SHORT: localList.append(pvd[i].getAsLong()) elif dtcheck==CAFE_FLOAT: localList.append(pvd[i].getAsDouble()) elif dtcheck==CAFE_ENUM: #if enum, string taken as native if self._c_cafe.isEnum(handleList[i]): localList.append(pvd[i].getAsString()) else: localList.append(pvd[i].getAsLong()) elif dtcheck==CAFE_CHAR: localList.append(pvd[i].getAsLong()) #( pvd[i].getAsChar()) elif dtcheck==CAFE_LONG: localList.append(pvd[i].getAsLong()) elif dtcheck==CAFE_DOUBLE: localList.append(pvd[i].getAsDouble()) else: localList.append(0) #no data else: localListInner=[] if dtcheck==CAFE_STRING: for j in range(0, pvd[i].getNelem()): localListInner.append(pvd[i].getAsString(j)) elif dtcheck==CAFE_SHORT: for j in range(0, pvd[i].getNelem()): localListInner.append(pvd[i].getAsLong(j)) elif dtcheck==CAFE_FLOAT: for j in range(0, pvd[i].getNelem()): localListInner.append(pvd[i].getAsDouble(j)) elif dtcheck==CAFE_ENUM: for j in range(0, pvd[i].getNelem()): #if enum, string taken as native if self._c_cafe.isEnum(handleList[i]): localListInner.append(pvd[i].getAsString(j)) else: localListInner.append(pvd[i].getAsLong(j)) elif dtcheck==CAFE_CHAR: for j in range(0, pvd[i].getNelem()): localListInner.append(pvd[i].getAsLong(j))#( pvd[i].getAsChar(j)) elif dtcheck==CAFE_LONG: for j in range(0, pvd[i].getNelem()): localListInner.append(pvd[i].getAsLong(j)) elif dtcheck==CAFE_DOUBLE: for j in range(0, pvd[i].getNelem()): localListInner.append(pvd[i].getAsDouble(j)) else: for j in range(0, pvd[i].getNelem()): localListInner.append(0) #no data localList.append(localListInner) p1 = pvdata() p1.value=localList p1.status=pvd[i].getStatus() p1.nelem=pvd[i].getNelem() p1.alarmStatus=pvd[i].getAlarmStatus() p1.alarmSeverity=pvd[i].getAlarmSeverity() pvd._etsNorm=pvd[i].getEpicsTimeStampAsUInt32() ll=[] ll.append((pvd[i]._etsNorm).secPastEpoch) ll.append((pvd[i]._etsNorm).nsec) p1.ts=ll pvd._etsDate=pvd[i].getEpicsTimeStampAsDate() ld=[] ld.append( (pvd[i]._etsDate).year ) ld.append( (pvd[i]._etsDate).mon ) ld.append( (pvd[i]._etsDate).day ) ld.append( (pvd[i]._etsDate).hour ) ld.append( (pvd[i]._etsDate).min ) ld.append( (pvd[i]._etsDate).sec ) ld.append( (pvd[i]._etsDate).nsec ) p1.tsDate=ld pvdList.append(p1) #free(pvd) return pvdList, status ################################################################################## #END: def getPVList(self, handlePV, dt): ################################################################################## ################################################################################## def printStatusIfError(self, handleList, statusList): ################################################################################## cdef str _METHOD_="printStatusIfError" if isinstance(handleList,(str,int,long)): handleListB=[] handleListB.append(handleList) handleList=[] handleList=handleListB if isinstance(handleList[0], (str)): handleList=self.checkForHandleList(handleList) elif not isinstance(handleList[0], (int, long)): raise Exception("{} {} {}".format(self.exString, _METHOD_, \ "First input argument should be a 'list' of if handles or if PVs")) if isinstance(statusList, (int,long)): statusListB=[] statusListB.append(statusList) statusList=[] statusList=statusListB if not isinstance(statusList, (list)): raise Exception("{} {} {}".format(self.exString, _METHOD_, \ "Second input argument should be of ")) if not isinstance(statusList[0], (int, long, float)): raise Exception("{} {} {}".format(self.exString, _METHOD_, \ "Second input argument should be a of ")) cdef vector[unsigned int] v #do next step to avoid: #warning: comparison between signed and unsigned integer expressions for i in range(0, len(handleList)): v.push_back(handleList[i]) #do this copy to avoid compiler warning messages return self._c_cafe.printStatusIfError(v, statusList) ################################################################################## ################################################################################## def getAsyn(self, handleList): ################################################################################## cdef str _METHOD_="getAsyn" if isinstance(handleList, (str,int,long)): handleListB=[] handleListB.append(handleList) handleList=[] handleList=handleListB if isinstance(handleList[0], (str)): handleList=self.checkForHandleList(handleList) elif not isinstance(handleList[0], (int, long)): raise Exception("{} {} {}".format(self.exString, _METHOD_, \ "First input argument should be a 'list' of if handles or if PVs")) cdef vector[unsigned int] v cdef vector[int] vStatus v.reserve (len(handleList)) vStatus.reserve(len(handleList)) #do next step to avoid: #warning: comparison between signed and unsigned integer expressions for i in range(0, len(handleList)): v.push_back(handleList[i]) #do this copy to avoid compiler warning messages #Need to copy to a vector since #Coercion from Python not allowed without the GIL with nogil: status=self._c_cafe.getV(v, vStatus) if (status!=ICAFE_NORMAL): if PYCAFE_PRINT_LEVEL>=PYCAFE_PRINT_LOW: print ("Error/Warning from def getAsyn: ") self._c_cafe.printStatusMessage(status) return status, vStatus ################################################################################## #END: def getAsyn(self, handleList): ################################################################################## ################################################################################## def waitForGetEvent(self,handlePV): ################################################################################## cdef str _METHOD_="waitForGetEvent(handlePV)" cdef unsigned int handle=0 if isinstance(handlePV, (int,long)) == 1: handle=handlePV elif isinstance(handlePV, (str)) == 1: handle=self.checkForHandle(handlePV) else: raise Exception("{} {} {}".format(self.exString, _METHOD_, \ "First input argument, should be if handle, else if PV")) with nogil: status=self._c_cafe.waitForGetEvent(handle) return status ################################################################################## #END: def waitForGetEvent(self, handlePV) ################################################################################## ################################################################################## def waitForBundledEvents(self, handleList): ################################################################################## cdef str _METHOD_="waitForBundledEvents(self, handleList)" if isinstance(handleList, (str,int,long)): handleListB=[] handleListB.append(handleList) handleList=[] handleList=handleListB if not isinstance(handleList, (list)): raise Exception ("EXCEPTION RAISED IN PyCafe def waitForBundledEvents. \n\ First input argument, should be of handles or PVs") if isinstance(handleList[0], (str)): handleList=self.checkForHandleList(handleList) elif not isinstance(handleList[0], (int, long)): raise Exception ("EXCEPTION RAISED IN PyCafe def waitForBundledEvents. \n\ First input argument, should be a 'list' of if handles or if PVs") cdef vector[unsigned int] v cdef vector[int] vRB v.reserve (len(handleList)) vRB.reserve(len(handleList)) for i in range(0, len(handleList)): v.push_back(handleList[i]) #do this copy to avoid compiler warning messages #Wait for bundle with nogil: status=self._c_cafe.waitForBundledEvents(v, vRB) if (status!=ICAFE_NORMAL): if PYCAFE_PRINT_LEVEL>=PYCAFE_PRINT_LOW: print ("Error in def waitForBundledEvents: ") self._c_cafe.printStatusMessage(status) return status return status, vRB ################################################################################## #END: def waitForBundledEvents(self, handleList): ################################################################################## ################################################################################## def getScalarArray(self, handleList, str dt='native', bint cacheFlag=False): ################################################################################## cdef str _METHOD_="getScalarArray(handleList, str dt='native')" #cdef float [::1] mvFloat #C-contiguous if not isinstance(handleList, (list)): raise Exception ("EXCEPTION RAISED IN PyCafe def getScalarList. \n\ First input argument, should be of handles or PVs") if isinstance(handleList[0], (str)): handleList=self.checkForHandleList(handleList) elif not isinstance(handleList[0], (int, long)): raise Exception ("EXCEPTION RAISED IN PyCafe def getScalarList. \n\ First input argument, should be a 'list' of if handles or if PVs") nelemPrevious= [] for i in range(0, len(handleList)): nelemPrevious.append(self._c_cafe.setNelemToOne(handleList[i])) #pack into numpy cdef vector[unsigned int] v cdef vector[int] vStatus v.reserve (len(handleList)) vStatus.reserve(len(handleList)) for i in range(0, len(handleList)): v.push_back(handleList[i]) #do this copy to avoid compiler warning messages cdef vector[int] vRB status=ICAFE_NORMAL if (cacheFlag == False): #Need to copy to a vector since #Coercion from Python not allowed without the GIL with nogil: status=self._c_cafe.getV(v, vStatus) #Check for error code 704: ICAFE_WAITING_FOR_PREV_CALLBACK #as this may mean we have a double handle instance. #This is not a problem as such but if this is the case let's #remove the error if the first getAsyn call for the handle in question was OK #Functionality not yet moved to CAFE:: #Required for when dt='native' if (status != ICAFE_NORMAL): for i in range(0,len(vStatus)): if (vStatus[i]==ICAFE_WAITING_FOR_PREV_CALLBACK): #getHandle for j in range(0,(i-1)): if(v[j]==v[i]): if (vStatus[j]==ICAFE_NORMAL): vStatus[i]=vStatus[j] #ca_poll() Not required as above will flush! #Wait for bundle with nogil: statusBundle=self._c_cafe.waitForBundledEvents(v, vRB) if (statusBundle!=ICAFE_NORMAL): if PYCAFE_PRINT_LEVEL>=PYCAFE_PRINT_LOW: print ("Error in def getScalarList: ") self._c_cafe.printStatusMessage(statusBundle) cdef unsigned int dtcheck=CAFE_NOT_REQUESTED #native type not yet know dtcheck=getMatchedDataType(dt, dtcheck) #print ("dt=", dt, "dtcheck=", dtcheck) if dtcheck in [CAFE_STRING]: self.vStr.clear() self.vStr.reserve(len(handleList)) with nogil: status=self._c_cafe.getCacheVStr(v, self.vStr, vStatus) for i in range(0, len(handleList)): self._c_cafe.setNelemToPrevious(handleList[i],nelemPrevious[i]) ##localList=[] ##statusList=[] #for i in range(0, len(self.vStr)): #localList.append( self.vStr[i]) return self.vStr, status, vStatus elif dtcheck in [CAFE_SHORT, CAFE_CHAR, CAFE_LONG]: self.vInt.clear() self.vInt.reserve(len(handleList)) with nogil: status=self._c_cafe.getCacheVLong(v, self.vInt, vStatus) #for i in range(0, len(vStatus)): #print ("status " , vStatus[i], " i", i, self._c_cafe.getPVFromHandle(handleList[i])) for i in range(0, len(handleList)): self._c_cafe.setNelemToPrevious(handleList[i],nelemPrevious[i]) ##localList=[] ##statusList=[] #for i in range(0, len(self.vInt)): return self.vInt, status, vStatus elif dtcheck in [CAFE_FLOAT, CAFE_DOUBLE]: self.vFloat.clear() self.vFloat.reserve(len(handleList)) with nogil: status=self._c_cafe.getCacheVDouble(v, self.vFloat, vStatus) for i in range(0, len(handleList)): self._c_cafe.setNelemToPrevious(handleList[i],nelemPrevious[i]) #for i in range(0, len(vStatus)): # print ("status/// " , vStatus[i], " i", i, self._c_cafe.getPVFromHandle(handleList[i])) #print ("overall status", status) ##localList=[] ##statusList=[] #Method A to return memory view #mvFloat = np.empty(len(handleList), dtype=np.float32) #for ij in range(0, len(handleList)): # mvFloat[ij]=self.vFloat[ij] #return mvFloat, status, vStatus #for i in range(0, len(self.vFloat)): return self.vFloat, status, vStatus #Native #cdef unsigned int nelemTotal=0 # for i in range(0, len(handleList)): # nelemTotal+=self.hh.getNelemNative(handleList[i]) #cdef int size_cdu = sizeof(CAFE_DATATYPE_UNION) #16 is size of boost_shared_ptr (size 40) #Create temporary group from handleList #Does group exist? cdef PVDataHolder * pvd = self._c_cafe.getPVData(v) #for i in range (0, len(handleList)): # print pvd[i].getPVName(), pvd[i].getAsString(), " [",i,"]" # print "" #print ("-----------------------------------------------------------------") #cdef PVDataHolder * pvd = \ #malloc( 100000000 + \ # len(handleList) * sizeof(PVDataHolder) + nelemTotal*size_cdu) #print "size_pvd=", sizeof(PVDataHolder) #print "sizeoverall", len(handleList) * sizeof(PVDataHolder)*10000 #Required to allocate memory for shared pointer for i in range(0, len(handleList)): pvd[i].setNelem(1) statusNoWait=self._c_cafe.getCachePVArrayNoWait(v, pvd) for i in range(0, len(handleList)): self._c_cafe.setNelemToPrevious(handleList[i],nelemPrevious[i]) statusList=[] statusFlag=True statusLocal=ICAFE_NORMAL if (cacheFlag==True): #if status !=ICAFE_NORMAL: # if PYCAFE_PRINT_LEVEL>=PYCAFE_PRINT_LOW: # self._c_cafe.printStatusMessage(status) #status=ICAFE_NORMAL for i in range(0, len(handleList)): statusList.append(pvd[i].getStatus()) if pvd[i].getStatus() != ICAFE_NORMAL: print ("Error in Element ", i, " from ", len(handleList), " in PyCafe def getScalarList") print ("Handle= ", handleList[i], " PV=", self.hh.getPVFromHandle(handleList[i])) print ("with error status=", pvd[i].getStatus()) self._c_cafe.printStatusMessage(pvd[i].getStatus()) if statusFlag: statusLocal =pvd[i].getStatus() statusFlag=False # #else: # statusList.append(status) #Wht not as a memoryView? cdef unsigned int dtn localList=[] for i in range(0, len(handleList)): dtn = pvd[i].getDataType(); dtcheck = getMatchedDataType(dt, dtn) #print ("dt=", dt, "dtn=", dtn, "dtcheck=", dtcheck) #print (pvd[i].getAsString()) #print (pvd[i].getAsDouble()) if dtcheck==CAFE_STRING: localList.append(pvd[i].getAsString()) elif dtcheck==CAFE_SHORT: localList.append(pvd[i].getAsLong()) elif dtcheck==CAFE_FLOAT: localList.append(pvd[i].getAsDouble()) elif dtcheck==CAFE_ENUM: #if enum, string taken as native if self._c_cafe.isEnum(self.hh.getHandleFromPV(pvd[i].getPVName()))==1: localList.append(pvd[i].getAsString()) else: localList.append(pvd[i].getAsLong()) elif dtcheck==CAFE_CHAR: localList.append( pvd[i].getAsLong()) # pvd[i].getAsChar() elif dtcheck==CAFE_LONG: localList.append(pvd[i].getAsLong()) elif dtcheck==CAFE_DOUBLE: localList.append(pvd[i].getAsDouble()) else: localList.append(0) if PYCAFE_PRINT_LEVEL>=PYCAFE_PRINT_HIGH: print ("def getScalarList:") print ("Entering 0 for element", i, "as channel is not connected!") #print (" vstatus = ", vStatus[i] , " pvd[i].status ", pvd[i].getStatus() ) #free(pvd) if (cacheFlag==True): return localList, statusLocal, statusList return localList, status, vStatus # use vstatus instead of statusList (as cache is NoWait) ################################################################################## #END: def getScalarList(self, handleList, dt): ################################################################################## ################################################################################## def getStrScalarList(self, handleList): ################################################################################## return self.getScalarList(handleList, dt='str') ################################################################################## def getIntScalarList(self, handleList): ################################################################################## return self.getScalarList(handleList, dt='int') ################################################################################## def getFloatScalarList(self, handleList): ################################################################################## return self.getScalarList(handleList, dt='float') ################################################################################## def getScalarList(self, handleList, str dt='native', bint cacheFlag=False): ################################################################################## cdef str _METHOD_="getScalarList(handleList, str dt='native')" #cdef float [::1] mvFloat #C-contiguous if not isinstance(handleList, (list)): raise Exception ("EXCEPTION RAISED IN PyCafe def getScalarList. \n\ First input argument, should be of handles or PVs") if isinstance(handleList[0], (str)): handleList=self.checkForHandleList(handleList) elif not isinstance(handleList[0], (int, long)): raise Exception ("EXCEPTION RAISED IN PyCafe def getScalarList. \n\ First input argument, should be a 'list' of if handles or if PVs") nelemPrevious= [] for i in range(0, len(handleList)): nelemPrevious.append(self._c_cafe.setNelemToOne(handleList[i])) #c=self.hh.getNelemClient(handleList[i]) #n=self.hh.getNelemNative(handleList[i]) #r=self.hh.getNelemRequest(handleList[i]) #print "c,n,r", c,n,r, "[",i,"]" #c=self.hh.getNelemToRetrieveFromCache(handleList[i]) #print "cache", c, "[",i,"]" #pack into vectors cdef vector[unsigned int] v cdef vector[int] vStatus v.reserve (len(handleList)) vStatus.reserve(len(handleList)) for i in range(0, len(handleList)): v.push_back(handleList[i]) #do this copy to avoid compiler warning messages cdef vector[int] vRB status=ICAFE_NORMAL if (cacheFlag == False): #Need to copy to a vector since #Coercion from Python not allowed without the GIL with nogil: status=self._c_cafe.getV(v, vStatus) #Check for error code 704: ICAFE_WAITING_FOR_PREV_CALLBACK #as this may mean we have a double handle instance. #This is not a problem as such but if this is the case let's #remove the error if the first getAsyn call for the handle in question was OK #Functionality not yet moved to CAFE:: #Required for when dt='native' if (status != ICAFE_NORMAL): for i in range(0,len(vStatus)): if (vStatus[i]==ICAFE_WAITING_FOR_PREV_CALLBACK): #getHandle for j in range(0,(i-1)): if(v[j]==v[i]): if (vStatus[j]==ICAFE_NORMAL): vStatus[i]=vStatus[j] #ca_poll() Not required as above will flush! #Wait for bundle with nogil: statusBundle=self._c_cafe.waitForBundledEvents(v, vRB) if (statusBundle!=ICAFE_NORMAL): if PYCAFE_PRINT_LEVEL>=PYCAFE_PRINT_LOW: print ("Error in def getScalarList: ") self._c_cafe.printStatusMessage(statusBundle) cdef unsigned int dtcheck=CAFE_NOT_REQUESTED #native type not yet know dtcheck=getMatchedDataType(dt, dtcheck) #print ("dt=", dt, "dtcheck=", dtcheck) if dtcheck in [CAFE_STRING]: self.vStr.clear() self.vStr.reserve(len(handleList)) with nogil: status=self._c_cafe.getCacheVStr(v, self.vStr, vStatus) for i in range(0, len(handleList)): self._c_cafe.setNelemToPrevious(handleList[i],nelemPrevious[i]) ##localList=[] ##statusList=[] #for i in range(0, len(self.vStr)): #localList.append( self.vStr[i]) return self.vStr, status, vStatus elif dtcheck in [CAFE_SHORT, CAFE_CHAR, CAFE_LONG]: self.vInt.clear() self.vInt.reserve(len(handleList)) with nogil: status=self._c_cafe.getCacheVLong(v, self.vInt, vStatus) #for i in range(0, len(vStatus)): #print ("status " , vStatus[i], " i", i, self._c_cafe.getPVFromHandle(handleList[i])) for i in range(0, len(handleList)): self._c_cafe.setNelemToPrevious(handleList[i],nelemPrevious[i]) ##localList=[] ##statusList=[] #for i in range(0, len(self.vInt)): return self.vInt, status, vStatus elif dtcheck in [CAFE_FLOAT, CAFE_DOUBLE]: self.vFloat.clear() self.vFloat.reserve(len(handleList)) with nogil: status=self._c_cafe.getCacheVDouble(v, self.vFloat, vStatus) for i in range(0, len(handleList)): self._c_cafe.setNelemToPrevious(handleList[i],nelemPrevious[i]) #for i in range(0, len(vStatus)): # print ("status/// " , vStatus[i], " i", i, self._c_cafe.getPVFromHandle(handleList[i])) #print ("overall status", status) ##localList=[] ##statusList=[] #Method A to return memory view #mvFloat = np.empty(len(handleList), dtype=np.float32) #for ij in range(0, len(handleList)): # mvFloat[ij]=self.vFloat[ij] #return mvFloat, status, vStatus #for i in range(0, len(self.vFloat)): return self.vFloat, status, vStatus #Native #cdef unsigned int nelemTotal=0 # for i in range(0, len(handleList)): # nelemTotal+=self.hh.getNelemNative(handleList[i]) #cdef int size_cdu = sizeof(CAFE_DATATYPE_UNION) #16 is size of boost_shared_ptr (size 40) #Create temporary group from handleList #Does group exist? cdef PVDataHolder * pvd = self._c_cafe.getPVData(v) #for i in range (0, len(handleList)): # print pvd[i].getPVName(), pvd[i].getAsString(), " [",i,"]" # print "" #print ("-----------------------------------------------------------------") #cdef PVDataHolder * pvd = \ #malloc( 100000000 + \ # len(handleList) * sizeof(PVDataHolder) + nelemTotal*size_cdu) #print "size_pvd=", sizeof(PVDataHolder) #print "sizeoverall", len(handleList) * sizeof(PVDataHolder)*10000 #Required to allocate memory for shared pointer for i in range(0, len(handleList)): pvd[i].setNelem(1) statusNoWait=self._c_cafe.getCachePVArrayNoWait(v, pvd) for i in range(0, len(handleList)): self._c_cafe.setNelemToPrevious(handleList[i],nelemPrevious[i]) statusList=[] statusFlag=True statusLocal=ICAFE_NORMAL if (cacheFlag==True): #if status !=ICAFE_NORMAL: # if PYCAFE_PRINT_LEVEL>=PYCAFE_PRINT_LOW: # self._c_cafe.printStatusMessage(status) #status=ICAFE_NORMAL for i in range(0, len(handleList)): statusList.append(pvd[i].getStatus()) if pvd[i].getStatus() != ICAFE_NORMAL: print ("Error in Element ", i, " from ", len(handleList), " in PyCafe def getScalarList") print ("Handle= ", handleList[i], " PV=", self.hh.getPVFromHandle(handleList[i])) print ("with error status=", pvd[i].getStatus()) self._c_cafe.printStatusMessage(pvd[i].getStatus()) if statusFlag: statusLocal =pvd[i].getStatus() statusFlag=False # #else: # statusList.append(status) #Wht not as a memoryView? cdef unsigned int dtn localList=[] for i in range(0, len(handleList)): dtn = pvd[i].getDataType(); dtcheck = getMatchedDataType(dt, dtn) #print ("dt=", dt, "dtn=", dtn, "dtcheck=", dtcheck) #print (pvd[i].getAsString()) #print (pvd[i].getAsDouble()) if dtcheck==CAFE_STRING: localList.append(pvd[i].getAsString()) elif dtcheck==CAFE_SHORT: localList.append(pvd[i].getAsLong()) elif dtcheck==CAFE_FLOAT: localList.append(pvd[i].getAsDouble()) elif dtcheck==CAFE_ENUM: #if enum, string taken as native if self._c_cafe.isEnum(self.hh.getHandleFromPV(pvd[i].getPVName()))==1: localList.append(pvd[i].getAsString()) else: localList.append(pvd[i].getAsLong()) elif dtcheck==CAFE_CHAR: localList.append( pvd[i].getAsLong()) # pvd[i].getAsChar() elif dtcheck==CAFE_LONG: localList.append(pvd[i].getAsLong()) elif dtcheck==CAFE_DOUBLE: localList.append(pvd[i].getAsDouble()) else: localList.append(0) if PYCAFE_PRINT_LEVEL>=PYCAFE_PRINT_HIGH: print ("def getScalarList:") print ("Entering 0 for element", i, "as channel is not connected!") #print (" vstatus = ", vStatus[i] , " pvd[i].status ", pvd[i].getStatus() ) #free(pvd) if (cacheFlag==True): return localList, statusLocal, statusList return localList, status, vStatus # use vstatus instead of statusList (as cache is NoWait) ################################################################################## #END: def getScalarList(self, handleList, dt): ################################################################################## ### # int alarmStatus=None, int alarmSev=None): ################################################################################## def getCompoundList(self, handleList, str dt='native', bint cacheFlag=False): ################################################################################## cdef str _METHOD_="getCompoundList(handleList, str dt='native')" if isinstance(handleList, (str)): handleList=self.getHandlesFromWithinGroup(handleList) else: if not isinstance(handleList, (list)): raise Exception ("EXCEPTION RAISED IN PyCafe def getCompoundList. \n\ First input argument, should be of handles or PVs") if isinstance(handleList[0], (str)): handleList=self.checkForHandleList(handleList) elif not isinstance(handleList[0], (int, long)): raise Exception ("EXCEPTION RAISED IN PyCafe def getCompoundList. \n\ First input argument, should be a 'list' of if handles or if PVs") #pack into vectors cdef vector[unsigned int] v cdef vector[int] vStatus cdef vector[int] vRB v.reserve (len(handleList)) vStatus.reserve(len(handleList)) cdef bint flagCompound=False cdef unsigned int nelemLocal=1 for i in range(0, len(handleList)): v.push_back(handleList[i]) #do this copy to avoid compiler warning messages if (nelemLocal==1): nelemLocal=self.hh.getNelemNative(handleList[i]) if nelemLocal > 1: flagCompound=True if (cacheFlag == False): #Need to copy to a vector since #Coercion from Python not allowed without the GIL with nogil: status=self._c_cafe.getV(v, vStatus) #ca_poll() Not required as above will flush! #Wait for bundle with nogil: statusBundle=self._c_cafe.waitForBundledEvents(v, vRB) if (statusBundle!=ICAFE_NORMAL): if PYCAFE_PRINT_LEVEL>=PYCAFE_PRINT_LOW: print ("Error in def getCompoundList: ") self._c_cafe.printStatusMessage(statusBundle) cdef unsigned int dtcheck=CAFE_NOT_REQUESTED #native type not yet know dtcheck=getMatchedDataType(dt, dtcheck) #Use Scalar if flagCompound == False: if dtcheck in [CAFE_STRING]: self.vStr.clear() self.vStr.reserve(len(handleList)) with nogil: status=self._c_cafe.getCacheVStr(v, self.vStr, vStatus) #localList=[] #statusList=[] #for i in range(0, len(self.vStr)): #localList.append( self.vStr[i]) return self.vStr, status, vStatus elif dtcheck in [CAFE_SHORT, CAFE_CHAR, CAFE_LONG]: self.vInt.clear() self.vInt.reserve(len(handleList)) with nogil: status=self._c_cafe.getCacheVLong(v, self.vInt, vStatus) #localList=[] #statusList=[] return self.vInt, status, vStatus elif dtcheck in [CAFE_FLOAT, CAFE_DOUBLE]: self.vFloat.clear() self.vFloat.reserve(len(handleList)) with nogil: status=self._c_cafe.getCacheVDouble(v, self.vFloat, vStatus) #localList=[] #statusList=[] return self.vFloat, status, vStatus #continue Can be a compound or native #Native #Create temporary group from handleList #Does group exist? cdef PVDataHolder * pvd = self._c_cafe.getPVData(v) #Required to allocate memory for shared pointer for i in range(0, len(handleList)): pvd[i].setNelem(self.hh.getNelemClient(handleList[i])) statusNoWait=self._c_cafe.getCachePVArrayNoWait(v, pvd) statusList=[] statusFlag=True statusLocal=ICAFE_NORMAL if (cacheFlag==True): for i in range(0, len(handleList)): statusList.append(pvd[i].getStatus()) if pvd[i].getStatus() != ICAFE_NORMAL: print ("Error in Element ", i, " from ", len(handleList), " in PyCafe def getCompundList") print ("Handle= ", handleList[i], " PV=", self.hh.getPVFromHandle(handleList[i])) print ("with error status=", pvd[i].getStatus()) self._c_cafe.printStatusMessage(pvd[i].getStatus()) if statusFlag: statusLocal =pvd[i].getStatus() statusFlag=False cdef unsigned int dtn localList=[] for i in range(0, len(handleList)): dtn = pvd[i].getDataType(); dtcheck = getMatchedDataType(dt, dtn) if pvd[i].getNelem() == 1: if dtcheck==CAFE_STRING: localList.append(pvd[i].getAsString()) elif dtcheck==CAFE_SHORT: localList.append(pvd[i].getAsLong()) elif dtcheck==CAFE_FLOAT: localList.append(pvd[i].getAsDouble()) elif dtcheck==CAFE_ENUM: #if enum, string taken as native if self._c_cafe.isEnum(handleList[i])==1: localList.append(pvd[i].getAsString()) else: localList.append(pvd[i].getAsLong()) elif dtcheck==CAFE_CHAR: localList.append( pvd[i].getAsChar()) elif dtcheck==CAFE_LONG: localList.append(pvd[i].getAsLong()) elif dtcheck==CAFE_DOUBLE: localList.append(pvd[i].getAsDouble()) else: localList.append(0) #no data else: localListInner=[] if dtcheck==CAFE_STRING: for j in range(0, pvd[i].getNelem()): localListInner.append(pvd[i].getAsString(j)) elif dtcheck==CAFE_SHORT: for j in range(0, pvd[i].getNelem()): localListInner.append(pvd[i].getAsLong(j)) elif dtcheck==CAFE_FLOAT: for j in range(0, pvd[i].getNelem()): localListInner.append(pvd[i].getAsDouble(j)) elif dtcheck==CAFE_ENUM: for j in range(0, pvd[i].getNelem()): #if enum, string taken as native if self._c_cafe.isEnum(handleList[i])==1: localListInner.append(pvd[i].getAsString(j)) else: localListInner.append(pvd[i].getAsLong(j)) elif dtcheck==CAFE_CHAR: for j in range(0, pvd[i].getNelem()): localListInner.append(pvd[i].getAsLong(j)) # pvd[i].getAsChar(j)) elif dtcheck==CAFE_LONG: for j in range(0, pvd[i].getNelem()): localListInner.append(pvd[i].getAsLong(j)) elif dtcheck==CAFE_DOUBLE: for j in range(0, pvd[i].getNelem()): localListInner.append(pvd[i].getAsDouble(j)) else: for j in range(0, pvd[i].getNelem()): localListInner.append(0) #no data localList.append(localListInner) #free(pvd) if (cacheFlag==True): return localList, statusLocal, statusList return localList, status, vStatus # use vstatus instead of statusList (as cache is NoWait) ################################################################################## #END: def getCompoundList(self, handleList, dt): ################################################################################## ################################################################################## def getCompoundPVGroup(self, ghandleName, str dt='native'): ################################################################################## cdef str _METHOD_="getCompoundPVGroup(ghandleName, str dt='native')" cdef unsigned int ghandle=0 if isinstance(ghandleName, (int,long)) == 1: ghandle=ghandleName elif isinstance(ghandleName, (str)) == 1: ghandle=self.checkForGroupHandle(ghandleName) else: raise Exception ("EXCEPTION RAISED IN PyCafe def getCompoundPVGroup. \n\ First input argument, should be if group handle, else if group name") handleList=[] handleList=self.getHandlesFromWithinGroup(ghandle) localList=[] statusList=[] cdef vector[unsigned int] hV for i in range(0, len(handleList)): hV.push_back(handleList[i]) self.hh.setCafeDbrTypeV(hV, DBR_TIME) localList, status, statusList=self.getCompoundList(handleList, dt) cdef PVGroup pvg with nogil: self._c_cafe.groupAttach(ghandle, pvg) cdef PVDataHolder * pvd pvd=pvg.getPVData() cdef pvdata p1 localListToStruct=[] cdef int groupStatus=ICAFE_NORMAL for i in range(0, pvg.getNPV()): p1 = pvdata() #pvd[i].setDouble(localList[i]) p1=PVDataHolderToStruct(pvd[i], dt) if not isinstance(localList[i],(list)): ll=[] ll.append(localList[i]) p1.value=ll else: p1.value=localList[i] #put into List! p1.status=statusList[i] if groupStatus == ICAFE_NORMAL: groupStatus=statusList[i] aStatSev=[] aStatSev=self.getAlarmStatusSeverity(handleList[i]) p1.alarmStatus=aStatSev[0] p1.alarmSeverity=aStatSev[1] p1.ts=self.getTimeStamp(handleList[i]) p1.tsDate=self.getTimeStampAsDate(handleList[i]) #p1.showMax(10) localListToStruct.append(p1) #for j in range (0, len(localListToStruct)): #localListToStruct[j].showMax(10) cpdef pvgroup pg pg = pvgroup() pg.pvdata=localListToStruct #pg.pvdata[0].showMax(10) pg.npv=pvg.getNPV() pg.name=pvg.getNameAsString() pg.groupStatus=groupStatus #pvg.getStatusGroup() pg.groupHandle=pvg.getGroupHandle() #pg.showMax(1) return pg ################################################################################## #END: def getCompoundPVGroup(self, handleList, dt): ################################################################################## ################################################################################## def getStrCache(self, handlePV): return self.getCache(handlePV,'str') ################################################################################## ################################################################################## def getIntCache(self, handlePV): return self.getCache(handlePV,'int') ################################################################################## ################################################################################## def getFloatCache(self, handlePV): return self.getCache(handlePV,'float') ################################################################################## ################################################################################## def getCache(self, handlePV, str dt='native'): cdef str _METHOD_="getCache(handlePV, str dt='native')" cdef unsigned int handle=0 if isinstance(handlePV, (int,long)) == 1: handle=handlePV elif isinstance(handlePV, (str)) == 1: handle=self.checkForHandle(handlePV) else: raise Exception ("EXCEPTION RAISED IN PyCafe def getCache. \n\ First input argument, should be if handle, else if PV") cdef long dtr=0 status=self.hh.getDataTypeNative(handle, dtr) if status != ICAFE_NORMAL: if PYCAFE_PRINT_LEVEL>=PYCAFE_PRINT_LOW: if handle == 0: self._c_cafe.printStatusMessage(status) else: self._c_cafe.printStatus(handle, status) if self.haveExceptions: raise Exception("EXCEPTION RAISED in PyCafe def getCache. Status = %d" %status) return None elif dtr in [CAFE_NO_ACCESS, CAFE_TYPENOTCONN]: if self._c_cafe.isChannelConnected(handle) is False: self._c_cafe.getChannelInfo(handle,self.channelInfo) if PYCAFE_PRINT_LEVEL>=PYCAFE_PRINT_LOW: self._c_cafe.printStatus(handle,self.channelInfo.getCafeConnectionState() ) if self.haveExceptions: _cyCafeException = CyCafeException(_type='cafe',_source=_METHOD_,_handle=handle, _pv=self._c_cafe.getPVFromHandle(handle), \ _ec=self.channelInfo.getCafeConnectionState(), _et=self.cs.code(self.channelInfo.getCafeConnectionState()),\ _ei=self.cs.info(self.channelInfo.getCafeConnectionState())) raise Exception(_cyCafeException) return [None] #Likely to be superfluous if PYCAFE_PRINT_LEVEL>=PYCAFE_PRINT_LOW: self._c_cafe.printStatus(handle,ICAFE_TYPENOTCONN) if self.haveExceptions: _cyCafeException = CyCafeException(_type='cafe',_source=_METHOD_,_handle=handle, _pv=self._c_cafe.getPVFromHandle(handle), \ _ec=ICAFE_TYPENOTCONN, _et=self.cs.code(ICAFE_TYPENOTCONN), _ei=self.cs.info(ICAFE_TYPENOTCONN)) raise Exception(_cyCafeException) return [None] cdef unsigned int dtcheck = dtr dtcheck=getMatchedDataType(dt, dtr) if dtcheck in [CAFE_STRING]: status=self._c_cafe.getCacheString(handle, self.valStr) if status==ICAFE_NORMAL: return self.valStr elif dtcheck in [CAFE_SHORT, CAFE_CHAR, CAFE_LONG]: status=self._c_cafe.getCacheLong(handle, self.valInt) if status==ICAFE_NORMAL: return self.valInt elif dtcheck in [CAFE_FLOAT, CAFE_DOUBLE]: status=self._c_cafe.getCacheDouble(handle, self.valFloat) if status==ICAFE_NORMAL: return self.valFloat elif dtcheck==CAFE_ENUM: #if enum, string taken as native if self._c_cafe.isEnum(handle): status=self._c_cafe.getCacheString(handle, self.valStr) if status==ICAFE_NORMAL: return self.valStr else: status=self._c_cafe.getCacheLong(handle, self.valInt) if status ==ICAFE_NORMAL: return self.valInt else: status=self.hh.getStatus(handle) if status == ICAFE_NORMAL: print ("This line in PyCafe def getCache should never appear!") print ("Datatype unknown, returning value 0") return 0 if status !=ICAFE_NORMAL: if PYCAFE_PRINT_LEVEL>=PYCAFE_PRINT_LOW: if handle == 0: self._c_cafe.printStatusMessage(status) else: self._c_cafe.printStatus(handle, status) if self.haveExceptions: _cyCafeException = CyCafeException(_type='cafe',_source=_METHOD_,_handle=handle, _pv=self._c_cafe.getPVFromHandle(handle), \ _ec=status, _et=self.cs.code(status), _ei=self.cs.info(status)) raise Exception(_cyCafeException) ################################################################################## ################################################################################## def getStrArrayCache(self, handlePV, str art='memoryview'): return self.getArrayCache(handlePV, dt='str', art=art) ################################################################################## ################################################################################## def getIntArrayCache(self, handlePV, str art='memoryview'): return self.getArrayCache(handlePV, dt='int', art=art) ################################################################################## ################################################################################## def getFloatArrayCache(self, handlePV, str art='memoryview'): return self.getArrayCache(handlePV, dt='float', art=art) ################################################################################## ################################################################################## def getArrayCache(self, handlePV, str dt='native', str art='memoryview'): ################################################################################## #Typed Memoryviews from K.W. Smith #Cython has a C-level type the typed memoryview, that conceptually overlaps #with the Python memoryiew and expands on it. A typed memory view is used to #view (share) data from a buffer-producing object. #A typed memoryview has a memory-view like interface and is easier to use than #workingwith C-lvevel buffers directly. And because a typed memoryview is designed #to work with the buffer protocol it supports any buffer-producing object efficiently #allowing sharing of data buffers without copying cdef str _METHOD_="getArrayCache" cdef unsigned int handle=0 if isinstance(handlePV, (int,long)) == 1: handle=handlePV elif isinstance(handlePV, (str)) == 1: handle=self.checkForHandle(handlePV) else: raise Exception("{} {} {}".format(self.exString, _METHOD_, \ "First input argument should be if handle, else if PV")) cdef: short * i16val int * ival double * dval float * fval dbr_string_t * sval cnp.int16_t [::1] mvShort #C-contiguous int [::1] mvInt #C-contiguous double [::1] mvDouble #C-contiguous float [::1] mvFloat #C-contiguous #str [:,::1] mvStr cnp.ndarray arr long dtr=0 int status unsigned int i unsigned int ij status=self.hh.getDataTypeNative(handle, dtr) if status != ICAFE_NORMAL: if PYCAFE_PRINT_LEVEL>=PYCAFE_PRINT_LOW: if handle == 0: self._c_cafe.printStatusMessage(status) else: self._c_cafe.printStatus(handle, status) if self.haveExceptions: _cyCafeException = CyCafeException(_type='cafe',_source=_METHOD_,_handle=handle, _pv=self._c_cafe.getPVFromHandle(handle), \ _ec=status, _et=self.cs.code(status), _ei=self.cs.info(status)) raise Exception(_cyCafeException) return [None] elif dtr in [CAFE_NO_ACCESS, CAFE_TYPENOTCONN]: if self._c_cafe.isChannelConnected(handle) is False: self._c_cafe.getChannelInfo(handle,self.channelInfo) if PYCAFE_PRINT_LEVEL>=PYCAFE_PRINT_LOW: self._c_cafe.printStatus(handle,self.channelInfo.getCafeConnectionState() ) if self.haveExceptions: _cyCafeException = CyCafeException(_type='cafe',_source=_METHOD_,_handle=handle, _pv=self._c_cafe.getPVFromHandle(handle), \ _ec=self.channelInfo.getCafeConnectionState(), _et=self.cs.code(self.channelInfo.getCafeConnectionState()),\ _ei=self.cs.info(self.channelInfo.getCafeConnectionState())) raise Exception(_cyCafeException) return [None] #Likely to be superfluous if PYCAFE_PRINT_LEVEL>=PYCAFE_PRINT_LOW: self._c_cafe.printStatus(handle,ICAFE_TYPENOTCONN) if self.haveExceptions: _cyCafeException = CyCafeException(_type='cafe',_source=_METHOD_,_handle=handle, _pv=self._c_cafe.getPVFromHandle(handle), \ _ec=ICAFE_TYPENOTCONN, _et=self.cs.code(ICAFE_TYPENOTCONN), _ei=self.cs.info(ICAFE_TYPENOTCONN)) raise Exception(_cyCafeException) return [None] cdef unsigned int nelemToRetrieveFromCache=self.hh.getNelemToRetrieveFromCache(handle) cdef unsigned int dtcheck = dtr dtcheck=getMatchedDataType(dt, dtr) #The elemnt type of a typed memoryview may be a numeric scalar type (int, float) #It may be a ctypedef alias, or it may be a structured type declared with e.g. cdef struct if dtcheck in [CAFE_STRING, CAFE_ENUM]: sval = malloc( nelemToRetrieveFromCache * sizeof(dbr_string_t)) status=self._c_cafe.getCacheDbrStringArray(handle, sval) locallist=[] if status==ICAFE_NORMAL: for i in range(0,nelemToRetrieveFromCache): locallist.append(sval[i]) free(sval) return locallist if status==ICAFE_NORMAL: if art in ['numpy','ndarray','numpy.ndarray']: mvStr = np.empty(nelemToRetrieveFromCache, dtype=(np.str_,40)) for i in range(0, nelemToRetrieveFromCache): mvStr[i]=str(sval[i]) free(sval) return mvStr elif art in ['memoryview','mv','memoryviewslice']: mvStr = np.empty(nelemToRetrieveFromCache, dtype=(np.str_,40), order='C') for ij in range(0, nelemToRetrieveFromCache): mvStr[ij]=str(sval[ij]) free(sval) return mvStr elif art in ['array','array.array']: print ("PyCafe.pyx getArray, 'array' type does not support array of strings; returning list") #RETURNING LIST - DOES NOT SUPPORT array of strings; arrayArray=[] for ij in range(0, nelemToRetrieveFromCache): arrayArray.append(str(sval[ij])) free(sval) return arrayArray elif art in ['ctypes', 'ctype']: ctypesArray=(ctypes.c_char_p*nelemToRetrieveFromCache)() #c_wchar_p is unicode! for ij in range(0, nelemToRetrieveFromCache): ctypesArray[ij]=(sval[ij]).encode('utf-8') free(sval) return ctypesArray else: print("Unknow array type in user request for art='",art,"'. Possible types are:") print("memoryview, numpy, array, ctypes") print("Returning memoryview") mvStr = np.empty(nelemToRetrieveFromCache, dtype=(np.str_,40), order='C') for ij in range(0, nelemToRetrieveFromCache): mvStr[ij]=sval[ij] free(sval) return mvStr elif dtcheck in [CAFE_SHORT, CAFE_CHAR]: i16val = malloc( nelemToRetrieveFromCache * sizeof(np.int16)) status=self._c_cafe.getCacheShortArray(handle, i16val) if status==ICAFE_NORMAL: #np.empty preferred, else mvInt does not get correct value for first couple of array elements if art in ['numpy','ndarray','numpy.ndarray']: mvShortNP = np.empty(nelemToRetrieveFromCache, dtype=np.int16, order='C') for ij in range(0, nelemToRetrieveFromCache): mvShortNP[ij]=i16val[ij] #arr=np.asarray(mvShort) free(i16val) return mvShortNP #arr elif art in ['memoryview','mv','memoryviewslice']: mvShort = np.empty(nelemToRetrieveFromCache, dtype=np.int16, order='C') for ij in range(0, nelemToRetrieveFromCache): mvShort[ij]=i16val[ij] free(i16val) return mvShort elif art in ['array','array.array']: arrayArray=array.array('h') for ij in range(0, nelemToRetrieveFromCache): arrayArray.append(i16val[ij]) free(i16val) return arrayArray elif art in ['ctypes', 'ctype']: ctypesArray=(ctypes.c_int16*nelemToRetrieveFromCache)() for ij in range(0, nelemToRetrieveFromCache): ctypesArray[ij]=i16val[ij] free(i16val) return ctypesArray else: print("Unknow array type in user request for art='",art,"'. Possible types are:") print("memoryview, numpy, array, ctypes") print("Returning memoryview") mvShort = np.empty(nelemToRetrieveFromCache, dtype=np.int16, order='C') for ij in range(0, nelemToRetrieveFromCache): mvShort[ij]=i16val[ij] free(i16val) return mvShort elif dtcheck in [CAFE_LONG]: ival = malloc( nelemToRetrieveFromCache * sizeof(np.int32)) status=self._c_cafe.getCacheLongArray(handle, ival) if status==ICAFE_NORMAL: if art in ['numpy','ndarray','numpy.ndarray']: mvIntNP = np.empty(nelemToRetrieveFromCache, dtype=np.int32, order='C') for ij in range(0, nelemToRetrieveFromCache): mvIntNP[ij]=ival[ij] free(ival) return mvIntNP #arr elif art in ['memoryview','mv','memoryviewslice']: mvInt = np.empty(nelemToRetrieveFromCache, dtype=np.int32, order='C') for ij in range(0, nelemToRetrieveFromCache): mvInt[ij]=ival[ij] free(ival) return mvInt elif art in ['array','array.array']: arrayArray=array.array('h') for ij in range(0, nelemToRetrieveFromCache): arrayArray.append(ival[ij]) free(ival) return arrayArray elif art in ['ctypes', 'ctype']: ctypesArray=(ctypes.c_int32*nelemToRetrieveFromCache)() for ij in range(0, nelemToRetrieveFromCache): ctypesArray[ij]=ival[ij] free(ival) return ctypesArray else: print("Unknow array type in user request for art='",art,"'. Possible types are:") print("memoryview, numpy, array, ctypes") print("Returning memoryview") mvInt = np.empty(nelemToRetrieveFromCache, dtype=np.int32, order='C') for ij in range(0, nelemToRetrieveFromCache): mvInt[ij]=ival[ij] free(ival) return mvInt elif dtcheck in [CAFE_FLOAT]: fval = malloc( nelemToRetrieveFromCache * sizeof(float)) status=self._c_cafe.getCacheFloatArray(handle, fval) if status==ICAFE_NORMAL: if art in ['numpy','ndarray','numpy.ndarray']: mvFloatNP = np.empty(nelemToRetrieveFromCache, dtype=np.float32) for ij in range(0, nelemToRetrieveFromCache): mvFloatNP[ij]=fval[ij] # pvd.getAsFloat(ij) free(fval) return mvFloatNP #arr elif art in ['memoryview','mv','memoryviewslice']: #Method A to return memory view mvFloat = np.empty(nelemToRetrieveFromCache, dtype=np.float32) for ij in range(0, nelemToRetrieveFromCache): mvFloat[ij]=fval[ij] free(fval) return mvFloat #Method B to return memory view ''' mvDoubleArray=cvarray(shape=(nelemToRetrieveFromCache,), itemsize=sizeof(double), format="d") cyarr_view=mvDoubleArray for i in range(0, nelemToRetrieveFromCache): #mvDoubleArray AVOID COPY TO mvDoubel Array!! cyarr_view[i]=dval[i] free(dval) return cyarr_view ''' elif art in ['array','array.array']: arrayArray=array.array('f') for ij in range(0, nelemToRetrieveFromCache): arrayArray.append(fval[ij]) free(fval) return arrayArray elif art in ['ctypes', "ctype"]: ctypesArray=(ctypes.c_float*nelemToRetrieveFromCache)() for ij in range(0, nelemToRetrieveFromCache): ctypesArray[ij]=fval[ij] free(fval) return ctypesArray else: print("Unknow array type in user request for art='",art,"'. Possible types are:") print("memoryview, numpy, array, ctypes") print("Returning memoryview") mvFloat = np.empty(nelemToRetrieveFromCache, dtype=np.float32) for ij in range(0, nelemToRetrieveFromCache): mvFloat[ij]=fval[ij] free(fval) return mvFloat elif dtcheck in [CAFE_DOUBLE]: dval = malloc( nelemToRetrieveFromCache * sizeof(double)) status=self._c_cafe.getDoubleArray(handle, dval) if status==ICAFE_NORMAL: if art in ['numpy','ndarray','numpy.ndarray']: mvDoubleNP = np.empty(nelemToRetrieveFromCache, dtype=np.float64) for ij in range(0, nelemToRetrieveFromCache): mvDoubleNP[ij]=dval[ij] free(dval) return mvDoubleNP #arr elif art in ['memoryview','mv','memoryviewslice']: #Method A to return memory view mvDouble = np.empty(nelemToRetrieveFromCache, dtype=np.float64) for ij in range(0, nelemToRetrieveFromCache): mvDouble[ij]=dval[ij] free(dval) return mvDouble elif art in ['array','array.array']: arrayArray=array.array('d') for ij in range(0, nelemToRetrieveFromCache): arrayArray.append(dval[ij]) free(dval) return arrayArray elif art in ['ctypes', "ctype"]: ctypesArray=(ctypes.c_double*nelemToRetrieveFromCache)() for ij in range(0, nelemToRetrieveFromCache): ctypesArray[ij]=dval[ij] free(dval) return ctypesArray else: print("Unknow array type in user request for art='",art,"'. Possible types are:") print("memoryview, numpy, array, ctypes") print("Returning memoryview") mvDouble = np.empty(nelemToRetrieveFromCache, dtype=np.float64) for ij in range(0, nelemToRetrieveFromCache): mvDouble[ij]=dval[ij] free(dval) return mvDouble if status !=ICAFE_NORMAL: if PYCAFE_PRINT_LEVEL>=PYCAFE_PRINT_LOW: if handle == 0: self._c_cafe.printStatusMessage(status) else: self._c_cafe.printStatus(handle, status) if self.haveExceptions: _cyCafeException = CyCafeException(_type='cafe',_source=_METHOD_,_handle=handle, _pv=self._c_cafe.getPVFromHandle(handle), \ _ec=status, _et=self.cs.code(status), _ei=self.cs.info(status)) raise Exception(_cyCafeException) return [None] ################################################################################## #END: def getArrayCache(self, handlePV, dt): ################################################################################## ################################################################################## def getPVStrCache(self, handlePV): return self.getPVCache(handlePV,'str') ################################################################################## ################################################################################## def getPVIntCache(self, handlePV): return self.getPVCache(handlePV,'int') ################################################################################## ################################################################################## def getPVFloatCache(self, handlePV): return self.getPVCache(handlePV,'float') ################################################################################## ################################################################################## def getPVCache(self, handlePV, str dt='native'): ################################################################################## cdef str _METHOD_="getPVCache(handlePV, str dt='native'" cdef unsigned int handle=0 if isinstance(handlePV, (int,long)) == 1: handle=handlePV elif isinstance(handlePV, (str)) == 1: handle=self.checkForHandle(handlePV) else: raise Exception ("EXCEPTION RAISED IN PyCafe def getPVCache. \n \ First input argument, should be if handle, else if PV") cdef PVDataHolder pvd pvd.setNelem(self.hh.getNelemToRetrieveFromCache(handle)) status=self._c_cafe.getCache(handle, pvd) if status !=ICAFE_NORMAL: if PYCAFE_PRINT_LEVEL>=PYCAFE_PRINT_LOW: if handle == 0: self._c_cafe.printStatusMessage(status) else: self._c_cafe.printStatus(handle, status) if self.haveExceptions: _cyCafeException = CyCafeException(_type='cafe',_source=_METHOD_,_handle=handle, _pv=self._c_cafe.getPVFromHandle(handle), \ _ec=status, _et=self.cs.code(status), _ei=self.cs.info(status)) raise Exception(_cyCafeException) pvd_valnone=PVDataHolderToStruct(pvd, dt) pvd_valnone.value[0]=None return pvd_valnone return PVDataHolderToStruct(pvd, dt) ################################################################################## #END def getPVCache(self, handlePV): ################################################################################## ################################################################################## def getCtrl(self, handlePV, str dt='native'): ################################################################################## cdef str _METHOD_="getCtrl(handlePV, str dt='native')" cdef unsigned int handle=0 if isinstance(handlePV, (int,long)) == 1: handle=handlePV elif isinstance(handlePV, (str)) == 1: handle=self.checkForHandle(handlePV) else: raise Exception ("EXCEPTION RAISED IN PyCafe def getCtrl. \n\ First input argument, should be if handle, else if PV") cdef PVCtrlHolder pvc pvc.setNelem(self.hh.getNelemClientCtrl(handle)) #do this dynamically cdef int status with nogil: status=self._c_cafe.getCtrl(handle, pvc) if status !=ICAFE_NORMAL: if PYCAFE_PRINT_LEVEL>=PYCAFE_PRINT_LOW: if handle == 0: self._c_cafe.printStatusMessage(status) else: self._c_cafe.printStatus(handle, status) if self.haveExceptions: _cyCafeException = CyCafeException(_type='cafe',_source=_METHOD_,_handle=handle, _pv=self._c_cafe.getPVFromHandle(handle), \ _ec=status, _et=self.cs.code(status), _ei=self.cs.info(status)) raise Exception(_cyCafeException) pvc_valnone=PVCtrlHolderToStruct(pvc, dt) pvc_valnone.value[0]=None return pvc_valnone return PVCtrlHolderToStruct(pvc, dt) ################################################################################## #END: def getCtrl(self, handlePV, dt='native'): ################################################################################## ################################################################################## def getCtrlCache(self, handlePV, str dt='native'): ################################################################################## cdef str _METHOD_="getCtrlCache(handlePV, str dt='native')" cdef unsigned int handle=0 if isinstance(handlePV, (int,long)) == 1: handle=handlePV elif isinstance(handlePV, (str)) == 1: handle=self.checkForHandle(handlePV) else: raise Exception ("EXCEPTION RAISED IN PyCafe def getCtrlCache. \n\ First input argument, should be if handle, else if PV") cdef PVCtrlHolder pvc pvc.setNelem(self.hh.getNelemToRetrieveFromCtrlCache(handle)) status=self._c_cafe.getCtrlCache(handle, pvc) if status !=ICAFE_NORMAL: if PYCAFE_PRINT_LEVEL>=PYCAFE_PRINT_LOW: if handle == 0: self._c_cafe.printStatusMessage(status) else: self._c_cafe.printStatus(handle, status) if self.haveExceptions: _cyCafeException = CyCafeException(_type='cafe',_source=_METHOD_,_handle=handle, _pv=self._c_cafe.getPVFromHandle(handle), \ _ec=status, _et=self.cs.code(status), _ei=self.cs.info(status)) raise Exception(_cyCafeException) pvc_valnone=PVCtrlHolderToStruct(pvc, dt) pvc_valnone.value[0]=None return pvc_valnone return PVCtrlHolderToStruct(pvc, dt) ################################################################################## #END: def getCtrlCache(self, handlePV, dt='native'): ################################################################################## ################################################################################## def groupMonitorStop(self, ghandleName): ################################################################################## cdef str _METHOD_="groupMonitorStop(ghandleName)" cdef unsigned int ghandle=0 if isinstance(ghandleName, (int,long)) == 1: ghandle=ghandleName elif isinstance(ghandleName, (str)) == 1: ghandle=self.checkForGroupHandle(ghandleName) else: _cyCafeException = CyCafeException(_type='cafe',_source=_METHOD_, \ _ei="First input argument, should be if group handle, else if group name") raise Exception(_cyCafeException) cdef PVGroup pvg with nogil: self._c_cafe.groupAttach(ghandle, pvg) cdef vector[int] vStatus vStatus.reserve(pvg.getNPV()) with nogil: status=self._c_cafe.groupMonitorStop(ghandle, vStatus) if status !=ICAFE_NORMAL: if PYCAFE_PRINT_LEVEL>=PYCAFE_PRINT_LOW: self._c_cafe.printStatusMessage(status) return status, vStatus ################################################################################## #END: def groupMonitorStop(self, ghandleName): ################################################################################## def getMonitorPolicyVector(self, handlePV, _monid): cdef unsigned int handle=0 if isinstance(handlePV, (int,long)): handle=handlePV elif isinstance(handlePV, (str)): handle=self.checkForHandle(handlePV, force=True) else: raise Exception ("EXCEPTION RAISED IN PyCafe def getMonitorPolicyVector \n\ First input argument, should be if handle, else if PV") cdef vector[MonitorPolicy] mpV self.hh.getMonitorPolicyVector(handle, mpV) cdef monitorpolicy mp mp = monitorpolicy() cdef unsigned int i for i in range (0, mpV.size()): if mpV[i].getMonitorID()== _monid: mp.monid=mpV[i].getMonitorID() mp.nelem=mpV[i].getNelem() mp.dataType=mpV[i].getDataType() mp.userArgs=mpV[i].getUserArgs() mp.dbrDataType=mpV[i].getDbrDataType() mp.cafeDbrType=mpV[i].getCafeDbrType() mp.mask=mpV[i].getMask() mp.maskHasDBE_PROPERTY=mpV[i].maskHasDBE_PROPERTY() mp.maskHasDBE_VALUE=mpV[i].maskHasDBE_VALUE() mp.maskHasDBE_LOG=mpV[i].maskHasDBE_LOG() mp.maskHasDBE_ALARM=mpV[i].maskHasDBE_ALARM() break return mp ################################################################################## def groupMonitorStart(self, ghandleName, object cb=None, DBR_TYPE dbr=DBR_TIME, unsigned int mask=DBE_VALUE|DBE_LOG|DBE_ALARM): ########################################################################################## cdef str _METHOD_="groupMonitorStart(ghandleName, object cb=None, DBR_TYPE dbr=DBR_TIME, unsigned int mask=DBE_VALUE|DBE_LOG|DBE_ALARM)" cdef unsigned int ghandle=0 if isinstance(ghandleName, (int,long)) == 1: ghandle=ghandleName elif isinstance(ghandleName, (str)) == 1: ghandle=self.checkForGroupHandle(ghandleName) else: _cyCafeException = CyCafeException(_type='cafe',_source=_METHOD_, \ _ei="First input argument, should be if group handle, else if group name") raise Exception(_cyCafeException) global monDictGlobal if dbr: if dbr not in [DBR_PLAIN, DBR_STS, DBR_TIME, DBR_GR, DBR_CTRL]: print ("***Warning*** from groupMonitorStart for handle(orPV)=", ghandleName) print ("dbr base type should be one of DBR_PLAIN, DBR_STS, DBR_TIME, DBR_GR, DBR_CTRL") print ("Assuming DBR_TIME") dbr=DBR_TIME global py_cb cdef vector[MonitorPolicy] mpV cdef unsigned int mpid cdef PVGroup pvg with nogil: self._c_cafe.groupAttach(ghandle, pvg) cdef MonitorPolicy * mp mp=self._c_cafe.createMonitorPolicyArray(pvg.getNPV()) for i in range(0, pvg.getNPV()): mp[i].setMask(mask) mp[i].setCafeDbrType(dbr) mpid=mp[i].getMonitorID() if cb: a=inspect.getargspec(cb) monDictGlobal[mpid]=cb if (len(a[0])==1): mp[i].setUserArgs( mpid) mp[i].setPyHandler() else: mp[i].setPyHandlerData() mpV.push_back(mp[i]) cdef vector[int] vStatus vStatus.reserve(pvg.getNPV()) with nogil: status=self._c_cafe.groupMonitorStart(ghandle, vStatus, mpV) if status !=ICAFE_NORMAL: if PYCAFE_PRINT_LEVEL>=PYCAFE_PRINT_LOW: self._c_cafe.printStatusMessage(status) return status, vStatus ################################################################################## ################################################################################## def groupMonitorStartWithCBList(self, ghandleName, list cb=None, DBR_TYPE dbr=DBR_TIME, unsigned int mask=DBE_VALUE|DBE_LOG|DBE_ALARM): ########################################################################################## cdef str _METHOD_="groupMonitorStartWithCBList(ghandleName, list cb=None, DBR_TYPE dbr=DBR_TIME, unsigned int mask=DBE_VALUE|DBE_LOG|DBE_ALARM)" cdef unsigned int ghandle=0 if isinstance(ghandleName, (int,long)) == 1: ghandle=ghandleName elif isinstance(ghandleName, (str)) == 1: ghandle=self.checkForGroupHandle(ghandleName) else: _cyCafeException = CyCafeException(_type='cafe',_source=_METHOD_, \ _ei="First input argument, should be if group handle, else if group name") raise Exception(_cyCafeException) global monDictGlobal if dbr: if dbr not in [DBR_PLAIN, DBR_STS, DBR_TIME, DBR_GR, DBR_CTRL]: print ("***Warning*** from groupMonitorStartWithCBList for handle(orPV)=", ghandleName) print ("dbr base type should be one of DBR_PLAIN, DBR_STS, DBR_TIME, DBR_GR, DBR_CTRL") print ("Assuming DBR_TIME") dbr=DBR_TIME if not isinstance(cb,(list)): raise Exception ("EXCEPTION RAISED IN PyCafe def groupMonitorStartWithCBList. \n\ Input cb should be of type and give the list of cb objects") global py_cb cdef vector[MonitorPolicy] mpV cdef unsigned int mpid cdef PVGroup pvg with nogil: self._c_cafe.groupAttach(ghandle, pvg) if (len(cb) != pvg.getNPV() ): print("No of group members is ", pvg.getNPV(), " while list of callback objects is", len(cb)) raise Exception ("EXCEPTION RAISED IN PyCafe def groupMonitorStartWithCBList. \n\ No of group members doe not match the length of callback object list") cdef MonitorPolicy * mp mp=self._c_cafe.createMonitorPolicyArray(pvg.getNPV()) for i in range(0, pvg.getNPV()): mp[i].setMask(mask) mp[i].setCafeDbrType(dbr) mpid=mp[i].getMonitorID() if cb[i]: a=inspect.getargspec(cb[i]) monDictGlobal[mpid]=cb[i] if (len(a[0])==1): mp[i].setUserArgs( mpid) mp[i].setPyHandler() else: mp[i].setPyHandlerData() mpV.push_back(mp[i]) cdef vector[int] vStatus vStatus.reserve(pvg.getNPV()) with nogil: status=self._c_cafe.groupMonitorStart(ghandle, vStatus, mpV) if status !=ICAFE_NORMAL: if PYCAFE_PRINT_LEVEL>=PYCAFE_PRINT_LOW: self._c_cafe.printStatusMessage(status) return status, vStatus ################################################################################## def getGroupStr(self, ghandleName): return self.getGroup(ghandleName, 'str') def getGroupInt(self, ghandleName): return self.getGroup(ghandleName, 'int') def getGroupFloat(self, ghandleName): return self.getGroup(ghandleName, 'float') ################################################################################## def getGroup(self, ghandleName, str dt='native'): cdef str _METHOD_="getGroup(ghandleName, str dt='native')" cdef unsigned int ghandle=0 if isinstance(ghandleName, (int,long)) == 1: ghandle=ghandleName elif isinstance(ghandleName, (str)) == 1: ghandle=self.checkForGroupHandle(ghandleName) else: _cyCafeException = CyCafeException(_type='cafe',_source=_METHOD_, \ _ei="First input argument, should be if group handle, else if group name") raise Exception(_cyCafeException) cdef PVGroup pvg with nogil: self._c_cafe.groupAttach(ghandle, pvg) cdef PVDataHolder * pvd pvd=pvg.getPVData(); for i in range (0, pvg.getNPV()): pvd[i].setHasAlarm(False) pvd[i].setHasTS(False) #pvd[i].setRule(False) pvg.setPVData(pvd) ##pvd=pvg.getPVData(); #print "get rule 0p", pvd[0].getRule() #print "get rule 1p", pvd[1].getRule() #print "get rule 2p", pvd[2].getRule() ## with nogil: status=self._c_cafe.groupGet(ghandle, pvg) if status == ECA_TIMEOUT : print ("======================================================") self._c_cafe.printStatusMessage(status) print ("TIMEOUT in getGroup; switching to getCompoundList") print ("======================================================") return self.getCompoundList(pvg.getNameAsString(), dt) if status !=ICAFE_NORMAL: if PYCAFE_PRINT_LEVEL>=PYCAFE_PRINT_LOW: self._c_cafe.printStatusMessage(status) #do not raise exception #raise Exception("EXCEPTION RAISED in PyCafe def getGroup. Status = %d" %status) #pvg.showMaxMax(5,10) pvd=pvg.getPVData() localList=[] statusList=[] cdef unsigned int dtn, dtcheck for i in range(0, pvg.getNPV()): dtn = pvd[i].getDataType(); dtcheck=getMatchedDataType(dt, dtn) statusList.append(pvd[i].getStatus()) if pvd[i].getNelem() == 1: if dtcheck==CAFE_STRING: localList.append(pvd[i].getAsString()) elif dtcheck==CAFE_SHORT: localList.append(pvd[i].getAsLong()) elif dtcheck==CAFE_FLOAT: localList.append(pvd[i].getAsDouble()) elif dtcheck==CAFE_ENUM: #if enum, string taken as native if self._c_cafe.isEnum(self.hh.getHandleFromPVWithinGroup(pvd[i].getPVName(),ghandle))==1: localList.append(pvd[i].getAsString()) else: localList.append(pvd[i].getAsLong()) elif dtcheck==CAFE_CHAR: localList.append( pvd[i].getAsChar()) elif dtcheck==CAFE_LONG: localList.append(pvd[i].getAsLong()) elif dtcheck==CAFE_DOUBLE: localList.append(pvd[i].getAsDouble()) else: localList.append(0) #no data else: localListInner=[] if dtcheck==CAFE_STRING: for j in range(0, pvd[i].getNelem()): localListInner.append(pvd[i].getAsString(j)) elif dtcheck==CAFE_SHORT: for j in range(0, pvd[i].getNelem()): localListInner.append(pvd[i].getAsLong(j)) elif dtcheck==CAFE_FLOAT: for j in range(0, pvd[i].getNelem()): localListInner.append(pvd[i].getAsDouble(j)) elif dtcheck==CAFE_ENUM: for j in range(0, pvd[i].getNelem()): #if enum, string taken as native if self._c_cafe.isEnum(self.hh.getHandleFromPVWithinGroup(pvd[i].getPVName(),ghandle))==1: localListInner.append(pvd[i].getAsString(j)) else: localListInner.append(pvd[i].getAsLong(j)) elif dtcheck==CAFE_CHAR: for j in range(0, pvd[i].getNelem()): localListInner.append(pvd[i].getAsLong(j)) # pvd[i].getAsChar(j)) elif dtcheck==CAFE_LONG: for j in range(0, pvd[i].getNelem()): localListInner.append(pvd[i].getAsLong(j)) elif dtcheck==CAFE_DOUBLE: for j in range(0, pvd[i].getNelem()): localListInner.append(pvd[i].getAsDouble(j)) else: for j in range(0, pvd[i].getNelem()): localListInner.append(0) #no data localList.append(localListInner) return localList, status, statusList ################################################################################## #END: def getGroup(self, ghandleName, dt='native'): ################################################################################## ################################################################################## def getGroupCache(self, ghandleName, str dt='native'): cdef str _METHOD_="getGroupCache(self, ghandleName, str dt='native')" cdef unsigned int ghandle=0 if isinstance(ghandleName, (int,long)) == 1: ghandle=ghandleName elif isinstance(ghandleName, (str)) == 1: ghandle=self.checkForGroupHandle(ghandleName) else: _cyCafeException = CyCafeException(_type='cafe',_source=_METHOD_, \ _ei="First input argument, should be if group handle, else if group name") raise Exception(_cyCafeException) cdef PVGroup pvg with nogil: self._c_cafe.groupAttach(ghandle, pvg) cdef PVDataHolder * pvd with nogil: status=self._c_cafe.groupGetCache(ghandle, pvg) if status !=ICAFE_NORMAL: if PYCAFE_PRINT_LEVEL>=PYCAFE_PRINT_LOW: self._c_cafe.printStatusMessage(status) #do not raise exception #raise Exception("EXCEPTION RAISED in PyCafe def getGroup. Status = %d" %status) pvd=pvg.getPVData() localList=[] statusList=[] cdef unsigned int dtn, dtcheck for i in range(0, pvg.getNPV()): dtn = pvd[i].getDataType(); dtcheck=getMatchedDataType(dt, dtn) statusList.append(pvd[i].getStatus()) if pvd[i].getNelem() == 1: if dtcheck==CAFE_STRING: localList.append(pvd[i].getAsString()) elif dtcheck==CAFE_SHORT: localList.append(pvd[i].getAsLong()) elif dtcheck==CAFE_FLOAT: localList.append(pvd[i].getAsDouble()) elif dtcheck==CAFE_ENUM: #if enum, string taken as native if self._c_cafe.isEnum(self.hh.getHandleFromPVWithinGroup(pvd[i].getPVName(),ghandle))==1: localList.append(pvd[i].getAsString()) else: localList.append(pvd[i].getAsLong()) elif dtcheck==CAFE_CHAR: localList.append( pvd[i].getAsChar()) elif dtcheck==CAFE_LONG: localList.append(pvd[i].getAsLong()) elif dtcheck==CAFE_DOUBLE: localList.append(pvd[i].getAsDouble()) else: localList.append(0) #no data else: localListInner=[] if dtcheck==CAFE_STRING: for j in range(0, pvd[i].getNelem()): localListInner.append(pvd[i].getAsString(j)) elif dtcheck==CAFE_SHORT: for j in range(0, pvd[i].getNelem()): localListInner.append(pvd[i].getAsLong(j)) elif dtcheck==CAFE_FLOAT: for j in range(0, pvd[i].getNelem()): localListInner.append(pvd[i].getAsDouble(j)) elif dtcheck==CAFE_ENUM: for j in range(0, pvd[i].getNelem()): #if enum, string taken as native if self._c_cafe.isEnum(self.hh.getHandleFromPVWithinGroup(pvd[i].getPVName(),ghandle))==1: localListInner.append(pvd[i].getAsString(j)) else: localListInner.append(pvd[i].getAsLong(j)) elif dtcheck==CAFE_CHAR: for j in range(0, pvd[i].getNelem()): localListInner.append(pvd[i].getAsLong(j)) # pvd[i].getAsChar(j)) elif dtcheck==CAFE_LONG: for j in range(0, pvd[i].getNelem()): localListInner.append(pvd[i].getAsLong(j)) elif dtcheck==CAFE_DOUBLE: for j in range(0, pvd[i].getNelem()): localListInner.append(pvd[i].getAsDouble(j)) else: for j in range(0, pvd[i].getNelem()): localListInner.append(0) #no data localList.append(localListInner) return localList, status, statusList ################################################################################## #END: def getGroup(self, ghandleName, dt='native'): ################################################################################## ################################################################################## def getPVGroupStr(self, ghandleName): return self.getPVGroup(ghandleName, dt='str') def getPVGroupInt(self, ghandleName): return self.getPVGroup(ghandleName, dt='int') def getPVGroupFloat(self, ghandleName): return self.getPVGroup(ghandleName, dt='float') ################################################################################## def getPVGroup(self, ghandleName, str dt='native'): cdef str _METHOD_="getPVGroup(ghandleName, str dt='native')" cdef unsigned int ghandle=0 if isinstance(ghandleName, (int,long)) == 1: ghandle=ghandleName elif isinstance(ghandleName, (str)) == 1: ghandle=self.checkForGroupHandle(ghandleName) #elif isinstance(ghandleName, (pvgroup)) == 1: # print ("We have a PV Group ", type(ghandleName) ) else: _cyCafeException = CyCafeException(_type='cafe',_source=_METHOD_, \ _ei="First input argument, should be if group handle, else if group name") raise Exception(_cyCafeException) cdef PVGroup pvg cdef PVDataHolder * pvd cdef int status with nogil: self._c_cafe.groupAttach(ghandle, pvg) pvd=pvg.getPVData() ''' for i in range (0, pvg.getNPV()): pvd[i].setHasAlarm(True) pvd[i].setHasTS(True) #pvd[i].setRule(True) pvg.setPVData(pvd) ''' with nogil: status=self._c_cafe.groupGet(ghandle, pvg) if status !=ICAFE_NORMAL: if PYCAFE_PRINT_LEVEL>=PYCAFE_PRINT_LOW: print("Error in PyCafe def getPVGroup. Status = %d" %status) self._c_cafe.printStatusMessage(status) #do not raise exception #raise Exception("EXCEPTION RAISED in PyCafe def getPVGroup. Status = %d" %status) if status == ECA_TIMEOUT: print ("======================================================") print ("TIMEOUT in getGroup; swithing to getCompoundPVGroup") print ("======================================================") return self.getCompoundPVGroup(ghandle,dt) pvd=pvg.getPVData() localList=[] for i in range(0, pvg.getNPV()): #print(pvd[i].getAsString(0), " " , pvd[i].getStatus()) #print(pvd[i].getEpicsTimeStampAsUInt32().secPastEpoch, " ", pvd[i].getEpicsTimeStampAsUInt32().nsec) localList.append(PVDataHolderToStruct(pvd[i], dt)) cpdef pvgroup pg pg = pvgroup() pg.pvdata=localList pg.npv=pvg.getNPV() pg.name=pvg.getNameAsString() pg.groupStatus=pvg.getStatusGroup() pg.groupHandle=pvg.getGroupHandle() #pg.showMax(1) return pg #localList, status ################################################################################## #END: def getPVGroup(self, ghandleName, str dt='native') ################################################################################## ################################################################################## def getPVGroupCache(self, ghandleName, str dt='native'): cdef str _METHOD_="getPVGroupCache" cdef unsigned int ghandle=0 if isinstance(ghandleName, (int,long)) == 1: ghandle=ghandleName elif isinstance(ghandleName, (str)) == 1: ghandle=self.checkForGroupHandle(ghandleName) #elif isinstance(ghandleName, (pvgroup)) == 1: # print ("We have a PV Group ", type(ghandleName) ) else: _cyCafeException = CyCafeException(_type='cafe',_source=_METHOD_, \ _ei="First input argument, should be if group handle, else if group name") raise Exception(_cyCafeException) cdef PVGroup pvg cdef PVDataHolder * pvd cdef int status with nogil: self._c_cafe.groupAttach(ghandle, pvg) print ("==============" ) print (_METHOD_) pvg.showMax(1) pvd=pvg.getPVData() status=self._c_cafe.groupGetCache(ghandle, pvg) pvg.showMax(1) print ("==============" ) print(status, pvg.getStatusGroup() ) print ("==============" ) if status !=ICAFE_NORMAL: if PYCAFE_PRINT_LEVEL>=PYCAFE_PRINT_LOW: print("Error in PyCafe def getPVGroupCache. Status = %d" %status) self._c_cafe.printStatusMessage(status) #do not raise exception #raise Exception("EXCEPTION RAISED in PyCafe def getPVGroup. Status = %d" %status) pvd=pvg.getPVData() localList=[] for i in range(0, pvg.getNPV()): #print(pvd[i].getAsString(0), " " , pvd[i].getStatus()) #print(pvd[i].getEpicsTimeStampAsUInt32().secPastEpoch, " ", pvd[i].getEpicsTimeStampAsUInt32().nsec) localList.append(PVDataHolderToStruct(pvd[i], dt)) cpdef pvgroup pg pg = pvgroup() pg.pvdata=localList pg.npv=pvg.getNPV() pg.name=pvg.getNameAsString() pg.groupStatus= pvg.getStatusGroup() pg.groupHandle=pvg.getGroupHandle() return pg ################################################################################## #END: def getPVGroup(self, ghandleName, str dt='native') ################################################################################## ################################################################################## def PVGroupValuesToList(self, pvgroup pg): glist=[] for i in range(0,pg.npv): if len(pg.pvdata[i].value)==1: glist.append(pg.pvdata[i].value[0]) else: iL=[] for j in range(0, len(pg.pvdata[i].value)): iL.append(pg.pvdata[i].value[j]) glist.append(iL) return glist ################################################################################## ################################################################################## def groupMemberList(self, str gname): cdef str _METHOD_="groupMemberList(self, str gname)" cdef vector[string] pvlist status=self._c_cafe.groupMemberList(gname, pvlist) if status !=ICAFE_NORMAL: if PYCAFE_PRINT_LEVEL>=PYCAFE_PRINT_LOW: self._c_cafe.printStatusMessage(status) #for i in range(0, len(pvlist)): # memberList.append(pvlist[i]) return pvlist ################################################################################## def grouping(self, char * gname, list _pvlist): cdef str _METHOD_="grouping(char * gname, list _pvlist)" cdef int status status=self._c_cafe.groupDefine(gname, _pvlist) if status !=ICAFE_NORMAL: if PYCAFE_PRINT_LEVEL>=PYCAFE_PRINT_LOW: self._c_cafe.printStatusMessage(status) cdef unsigned int ghandle=0 cdef char * _gname=gname #try: # self._c_cafe.groupOpen(_gname, ghandle) #except: # raise Exception("EXCEPTION RAISED in PyCafe def grouping. ERROR OPENING PVGROUP= %s" %_gname) try: status=self._c_cafe.groupOpen(_gname, ghandle) except: _cyCafeException = CyCafeException(_type='cafe',_source=_METHOD_,_handle=ghandle, _pv=_gname, \ _ec=ECA_ALLOCMEM, _et=self.cs.code(ECA_ALLOCMEM), _ei=self.cs.info(ECA_ALLOCMEM)) raise Exception(_cyCafeException) if status != ICAFE_NORMAL: _cyCafeException = CyCafeException(_type='cafe',_source=_METHOD_,_handle=ghandle, _pv=_gname, \ _ec=status, _et=self.cs.code(status), _ei=self.cs.info(status)) raise Exception(_cyCafeException) #cdef PVGroup pvg #self._c_cafe.groupAttach(ghandle, pvg); cdef: list localList list statusList if self._c_cafe.channelOpenGroupPolicy.getWhenToFlushSendBuffer()==FLUSH_NOW: localList,status,statusList= self.getGroup(ghandle) if status !=ICAFE_NORMAL: if PYCAFE_PRINT_LEVEL>=PYCAFE_PRINT_LOW: print ("") print ("Error in def grouping for group named", _gname) self._c_cafe.printStatusMessage(status) print ("Analysing statusList[]...") for i in range(0, len(statusList)): if statusList[i] !=ICAFE_NORMAL: print ("PV", _pvlist[i], "[",i,"]", " has error: ") self._c_cafe.printStatusMessage(statusList[i]) print ("") return ghandle ################################################################################## def defineGroup(self, char * gname, list _pvlist): #cdef vector[const char *] pvlist #for i in range(0, len(_pvlist)): # pvlist.push_back(_pvlist[i]) status=self._c_cafe.groupDefine(gname, _pvlist) if status !=ICAFE_NORMAL: if PYCAFE_PRINT_LEVEL>=PYCAFE_PRINT_LOW: self._c_cafe.printStatusMessage(status) return status ################################################################################## ################################################################################## def groupOpen(self, char * gname): cdef str _METHOD_="groupOpen(char * gname)" if isinstance(gname, (str)) == 0: _cyCafeException = CyCafeException(_type='cafe',_source=_METHOD_, \ _ei="First input argument should be for group name") raise Exception(_cyCafeException) cdef unsigned int ghandle=0 cdef char * _gname=gname try: status=self._c_cafe.groupOpen(_gname, ghandle) except: _cyCafeException = CyCafeException(_type='cafe',_source=_METHOD_,_handle=ghandle, _pv=_gname, \ _ec=ECA_ALLOCMEM, _et=self.cs.code(ECA_ALLOCMEM), _ei=self.cs.info(ECA_ALLOCMEM)) raise Exception(_cyCafeException) if status != ICAFE_NORMAL: _cyCafeException = CyCafeException(_type='cafe',_source=_METHOD_,_handle=ghandle, _pv=_gname, \ _ec=status, _et=self.cs.code(status), _ei=self.cs.info(status)) raise Exception(_cyCafeException) return ghandle ################################################################################## ################################################################################## def groupClose(self, gHandleName): cdef str _METHOD_="groupClose(gHandleName)" cdef unsigned int gHandle=0 cdef str _gname=None status=ICAFE_NORMAL if isinstance(gHandleName, (int,long)): gHandle=gHandleName elif isinstance(gHandleName, (str)): _gname=gHandleName gHandle=self.checkForGroupHandle(gHandleName) else: _cyCafeException = CyCafeException(_type='cafe',_source=_METHOD_, \ _ei="First input argument, should be if group handle, else if group name") raise Exception(_cyCafeException) if gHandle == 0: status=ECAFE_INVALID_GROUP_HANDLE if PYCAFE_PRINT_LEVEL>=PYCAFE_PRINT_LOW: self._c_cafe.printStatusMessage(status) _cyCafeException = CyCafeException(_type='cafe',_source=_METHOD_,_handle=gHandle, _pv=_gname, \ _ec=status, _et=self.cs.code(status), _ei=self.cs.info(status)) raise Exception(_cyCafeException) status=self._c_cafe.groupClose(gHandle) if status != ICAFE_NORMAL: _cyCafeException = CyCafeException(_type='cafe',_source=_METHOD_,_handle=gHandle, _pv=_gname, \ _ec=status, _et=self.cs.code(status), _ei=self.cs.info(status)) raise Exception(_cyCafeException) return status ################################################################################## def getNoMonitors(self, handlePV): cdef str _METHOD_="getNoMonitors(handlePV)" cdef unsigned int handle=0 if isinstance(handlePV, (int,long)) == 1: handle=handlePV elif isinstance(handlePV, (str)) == 1: handle=self.checkForHandle(handlePV) else: _cyCafeException = CyCafeException(_type='cafe',_source=_METHOD_, \ _ei="First input argument, should be if handle, else if PV") raise Exception(_cyCafeException) return self.hh.getNmonitor(handle) ################################################################################## ################################################################################## def getMonitorIDs(self, handlePV): cdef str _METHOD_="getMonitorIDs(handlePV)" cdef unsigned int handle=0 if isinstance(handlePV, (int,long)) == 1: handle=handlePV elif isinstance(handlePV, (str)) == 1: handle=self.checkForHandle(handlePV) else: _cyCafeException = CyCafeException(_type='cafe',_source=_METHOD_, \ _ei="First input argument, should be if handle, else if PV") raise Exception(_cyCafeException) return self.hh.getMonitorIDs(handle); ################################################################################## ########################################################################################## def monitorStart(self, handlePV, object cb=None, DBR_TYPE dbr=DBR_TIME, unsigned int mask=DBE_VALUE|DBE_LOG|DBE_ALARM): cdef str _METHOD_="monitorStart(handlePV, object cb=None, DBR_TYPE dbr=DBR_TIME, unsigned int mask=DBE_VALUE|DBE_LOG|DBE_ALARM)" pv=None cdef int status=ICAFE_NORMAL #cdef pCallback my_callback #my_callback=callbackHandlerMonitor cdef unsigned int handle=0 if isinstance(handlePV, (int,long)) == 1: handle=handlePV elif isinstance(handlePV, (str)) == 1: pv=handlePV handle=self.checkForHandle(handlePV) else: _cyCafeException = CyCafeException(_type='cafe',_source=_METHOD_, \ _ei="First input argument, should be if handle, else if PV") raise Exception(_cyCafeException) #py_cb_handle phase out; us fn in dictionary! #global py_cb_handle global py_cb #if cb: # py_cb=cb #Does channel Exist? if self._c_cafe.isValid(handle) == 0: status=ECAFE_INVALID_HANDLE if self.haveExceptions: _cyCafeException = CyCafeException(_type='cafe',_source=_METHOD_,_handle=handle, _pv=pv, \ _ec=status, _et=self.cs.code(status), _ei=self.cs.info(status)) raise Exception(_cyCafeException) return status; cdef MonitorPolicy mp cdef unsigned int mpid=mp.getMonitorID() mp.setMask(mask) #print ("dbr=", dbr) self._c_cafe.getChannelInfo(handle,self.channelInfo) #print ("nativeDataType=", self.channelInfo.getDataType()) if dbr in [DBR_PLAIN, DBR_STS, DBR_TIME, DBR_GR, DBR_CTRL]: #set Native Datatype first mp.setDataType(self.channelInfo.getDataType()); mp.setCafeDbrType(dbr) #print ("def monitorStart ", mp.getCafeDbrType()) #print ("def monitorStart ", mp.getDbrDataType()) else: print ("***Warning*** from monitorStart for handle=",handlePV) print ("dbr base type should be one of DBR_PLAIN, DBR_STS, DBR_TIME, DBR_GR, DBR_CTRL") print ("Assuming DBR_TIME") mp.setDataType(self.channelInfo.getDataType()); mp.setCafeDbrType(DBR_TIME) #if cb: # # print "py_cb_handle", len(a[0]) global monDictGlobal #print ("MONITOR START (self, handlePV, object cb=None, DBR_TYPE dbr=DBR_TIME, unsigned int mask) ") #print (monDictGlobal) if cb: a=inspect.getargspec(cb) #print (a) if(len(a[0])==1): ##py_cb_handle=cb #self.monidList.append(mpid) #self.moncbList.append(cb) ##self.monDict[mpid]=cb monDictGlobal[mpid]=cb #print (monDictGlobal) #print self.monidList #print self.moncbList #print self.monDict # #print "mpid = ", mpid mp.setUserArgs( mpid) mp.setPyHandler() #print (mp.getUserArgs()) else: py_cb=cb mp.setPyHandlerData() #else: # mp.setHandler(callbackHandlerMonitor_wrapper) with nogil: status=self._c_cafe.monitorStart(handle,mp) #Need this to allow a fraction of a second for the callback fn to be called #if setPyHandler is used if (self.getMonitorWhenToFlushSendBuffer == FLUSH_NOW): time.sleep(0.01); if status !=ICAFE_NORMAL: if PYCAFE_PRINT_LEVEL>=PYCAFE_PRINT_LOW: if handle == 0: self._c_cafe.printStatusMessage(status) else: self._c_cafe.printStatus(handle, status) #do not raise an exception #raise Exception("EXCEPTION RAISED in PyCafe def monitorStart. Status = %d" %status) return mpid ################################################################################## ################################################################################## def monitorStop(self, handlePV, mpid=None): cdef str _METHOD_="monitorStop(handlePV, mpid=None)" cdef unsigned int handle=0 if isinstance(handlePV, (int,long)) == 1: handle=handlePV elif isinstance(handlePV, (str)) == 1: handle=self.checkForHandle(handlePV) else: _cyCafeException = CyCafeException(_type='cafe',_source=_METHOD_, \ _ei="First input argument, should be if handle, else if PV") raise Exception(_cyCafeException) cdef int status cdef unsigned int mpidUI global monDictGlobal if mpid: if isinstance(mpid, (int,long)): mpidUI=mpid with nogil: status=self._c_cafe.monitorStopWithID(handle, mpidUI) time.sleep(0.01) if (status==ICAFE_NORMAL): #index=self.monidList.index(mpidUI) #self.monidList.remove(mpidUI) #self.moncbList.remove(self.moncbList[index]) #del self.monDict[mpidUI] #print (monDictGlobal) #DELETE ENTRY ONLY IF IT EXISTS! if monDictGlobal.has_key(mpidUI): del monDictGlobal[mpidUI] else: raise Exception ("EXCEPTION RAISED IN PyCafe def monitorStop. \n\ monitorPolicy ID (mpid) should be ") else: with nogil: status=self._c_cafe.monitorStop(handle) time.sleep(0.01) 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()): #index=self.monidList.index(mpidUIV[i]) #self.monidList.remove(mpidUIV[i]) #self.moncbList.remove(self.moncbList[index]) #del self.monDict[mpidUIV[i]] if monDictGlobal.has_key(mpidUIV[i]): del monDictGlobal[mpidUIV[i]] #monDictGlobal.remove(mpidUIV[i]) if status !=ICAFE_NORMAL: if PYCAFE_PRINT_LEVEL>=PYCAFE_PRINT_LOW: if handle == 0: self._c_cafe.printStatusMessage(status) else: self._c_cafe.printStatus(handle, status) #do not raise an exception #raise Exception("EXCEPTION RAISED in PyCafe def monitorStop. Status = %d" %status) return status ################################################################################## ################################################################################## def monitorStopAll(self): cdef str _METHOD_="monitorStopAll()" global monDictGlobal cdef int status with nogil: status=self._c_cafe.monitorStopAll() #give plenty of time for monitors to stop! #print ("-----------------------------------------------------------------") #print self.monidList #print self.moncbList #print self.monDict #print (monDictGlobal) #print ("------------------------------------------------------------------") #del self.monidList[:] #del self.moncbList[:] #self.monDict.clear() time.sleep(0.5) monDictGlobal.clear() #print self.monDict #print monDictGlobal if status !=ICAFE_NORMAL: if PYCAFE_PRINT_LEVEL>=PYCAFE_PRINT_LOW: self._c_cafe.printStatusMessage(status) raise Exception("EXCEPTION RAISED in PyCafe def monitorStopAll. Status = %d" %status) return status ################################################################################## ################################################################################## def set(self, handlePV, valSet): cdef str _METHOD_="set(handlePV, valSet)" cdef unsigned int handle=0 if isinstance(handlePV, (int,long)): handle=handlePV elif isinstance(handlePV, (str)): handle=self.checkForHandle(handlePV) else: _cyCafeException = CyCafeException(_type='cafe',_source=_METHOD_, \ _ei="First input argument, should be if handle, else if PV") raise Exception(_cyCafeException) #CHECK FOR ALL DATA TYPES! cdef unsigned short valType=CAFE_STRING cdef int status=ICAFE_NORMAL cdef float valSetF cdef double valSetD cdef int valSetI cdef long long valSetLL cdef short valSetShort cdef unsigned short valSetUShort cdef unsigned char valSetChar cdef string valSetS cdef vector[double] vecD cdef vector[float] vecF cdef vector[short] vecShort cdef vector[unsigned short] vecUShort cdef vector[dbr_char_t] vecChar cdef vector[dbr_long_t] vecI cdef vector[string] vecS cdef unsigned int nLA=0 cdef tuple ctypesString = (ctypes.c_wchar, ctypes.c_char_p, ctypes.c_wchar_p) cdef tuple ctypesUChar = (ctypes.c_char, ctypes.c_ubyte, ctypes.c_bool, ctypes.c_uint8, ) cdef tuple ctypesShort = (ctypes.c_int16, ctypes.c_int8, ctypes.c_short, ctypes.c_byte) cdef tuple ctypesUShort = (ctypes.c_uint16,ctypes.c_ushort) cdef tuple ctypesInt = (ctypes.c_int, ctypes.c_int32, \ ctypes.c_long, ctypes.c_size_t) cdef tuple ctypesLongLong=(ctypes.c_uint, ctypes.c_uint32, ctypes.c_int64, ctypes.c_uint64, \ ctypes.c_ulong,ctypes.c_ulonglong, ctypes.c_longdouble, \ ctypes.c_longlong, ctypes.c_ssize_t, \ ctypes.c_void_p, ctypes.c_voidp) # ctypes.c_char, ctypes.c_float, ctypes.c_double are separate cdef tuple dtypesString = (np.str_, np.unicode_) cdef tuple dtypesUChar = (np.ubyte, np.bool8, np.bool_, np.uint8) cdef tuple dtypesShort = (np.byte, np.short, np.int8, np.int16) cdef tuple dtypesUShort = (np.uint16,np.ushort) cdef tuple dtypesInt = (np.int_, np.intc, np.int32, np.uintp) cdef tuple dtypesLongLong= (np.uint, np.uintc, np.uint32, np.int64, np.uint64, \ np.ulonglong, np.longlong, np.intp, np.uintp) cdef tuple dtypesFloat = (np.single, np.float16, np.float32) cdef tuple dtypesDouble = (np.double, np.float_, np.float64) #List: Major[0] Minor[1] Patch[2] 'final'[3] 0 [4] #print "type= // ", type(valSet) cdef bint isGoodType=False cdef bint isBytesType=False # print('set method', type(valSet)) # print("is instance array.array", isinstance(valSet, array.array)) # print("is instance np.ndarray", isinstance(valSet, np.ndarray)) # print("is instance memoryview", isinstance(valSet, memoryview)) # print("is instance ctypes float", isinstance(valSet, ctypes.c_float)) # print("is instance ctypes long ", isinstance(valSet, ctypes.c_long )) # print("is instance ctypes int ", isinstance(valSet, ctypes.c_int )) # print("is instance int ", isinstance(valSet, int )) # print("is instance ctypes char_p ", isinstance(valSet, ctypes.c_char_p )) # print("is instance ctypes Array ", isinstance(valSet, ctypes.Array )) # print("is instance bytes ", isinstance(valSet, bytes )) # print("is instance bytearrays ", isinstance(valSet, bytearray )) # ctypes.c_buffer is of class function # crtpes.c_buffer(b'abc') is of rtype ctypes.Array (!)) #print("is instance ctypes buffer ", isinstance(valSet, ctypes.c_buffer )) # no such type! # dir(ctypes) # print(type(valSet)) # print (valSet.__class__) cdef str classType = (valSet.__class__).__name__ cdef str substringmv = "_memoryviewslice" #print ("python Version", self.pythonVersion[0]) #Cython does not know about PyCafe._memoryviewslice #if (isinstance(valSet,PyCafe._memoryviewslice)): # print('OK for memoryview') if ( (self.pythonVersion[0] > 2 ) or (self.pythonVersion[0] == 2 and self.pythonVersion[1]>6) ) : if isinstance(valSet,(list, array.array, np.ndarray, cython.view.memoryview, memoryview, ctypes.Array)): isGoodType=True else: if isinstance(valSet,(list, array.array, np.ndarray, ctypes.Array)): isGoodType=True if (isGoodType==False): if (substringmv in classType): isGoodType=True #This is to cater for ctypes.c_buffer which is an instance of ctypes.Array #where the element of the array is of type bytes - there need to match to cafe.setString if isinstance(valSet,ctypes.Array): if isinstance(valSet[0],bytes): isGoodType=False isBytesType=True #where the element of the array is of type bytes - there need to match to cafe.setSrting #if isinstance(valSet,np.ndarray): #print ("np.ndarray is true") #print (type(valSet[0])) #if isinstance(valSet[0],bytes): #isGoodType=False #isBytesType=True #print("isGoodType ", isGoodType) #print("isBytesType ", isBytesType) if isGoodType: #print('set method', type(valSet[0])) nLA=len(valSet) #Just check on first element if array.array etc.. if not isinstance(valSet, (list)): #if isinstance(valSet, (array.array, np.ndarray, cython.view.memoryview, memoryview)): nLA=1 for i in range(0, nLA): if isinstance(valSet[i],(str, bytes)): valType=CAFE_STRING break elif isinstance(valSet[i],dtypesString): valType=CAFE_STRING break elif isinstance(valSet[i],(float)): valType=CAFE_DOUBLE elif isinstance(valSet[i],(dtypesDouble)): valType=CAFE_DOUBLE elif isinstance(valSet[i],(dtypesFloat)): valType=CAFE_FLOAT elif isinstance(valSet[i],(long, int)): valType=CAFE_LONG elif isinstance(valSet[i], dtypesInt+dtypesLongLong+dtypesUChar): valType=CAFE_LONG elif isinstance(valSet[i], dtypesShort): valType=CAFE_SHORT elif isinstance(valSet[i], dtypesUShort): valType=CAFE_USHORT else: print("PyCafe.pyx: We do not cater for type ", type(valSet[i]), " and thus assume a string" ) valType=CAFE_STRING break # valSet to vector since # coercion from Python not allowed without the GIL if valType==CAFE_DOUBLE: vecD.reserve(len(valSet)) for i in range(0, len(valSet)): vecD.push_back(valSet[i]) with nogil: status=self._c_cafe.setVDouble(handle, vecD) elif valType==CAFE_FLOAT: vecF.reserve(len(valSet)) for i in range(0, len(valSet)): vecF.push_back(valSet[i]) with nogil: status=self._c_cafe.setVFloat(handle, vecF) elif valType==CAFE_LONG: vecI.reserve(len(valSet)) for i in range(0, len(valSet)): vecI.push_back(valSet[i]) with nogil: status=self._c_cafe.setVLong(handle, vecI) elif valType==CAFE_SHORT: vecShort.reserve(len(valSet)) for i in range(0, len(valSet)): vecShort.push_back(valSet[i]) with nogil: status=self._c_cafe.setVShort(handle, vecShort) elif valType==CAFE_USHORT: vecUShort.reserve(len(valSet)) for i in range(0, len(valSet)): vecUShort.push_back(valSet[i]) with nogil: status=self._c_cafe.setVUShort(handle, vecUShort) elif valType==CAFE_CHAR: vecChar.reserve(len(valSet)) for i in range(0, len(valSet)): vecChar.push_back(valSet[i]) with nogil: status=self._c_cafe.setVChar(handle, vecChar) elif valType==CAFE_STRING: vecS.reserve(len(valSet)) for i in range(0, len(valSet)): vecS.push_back(str(valSet[i])) with nogil: status=self._c_cafe.setVString(handle, vecS) elif isBytesType: #print("isBytesType") valSetS=valSet.value with nogil: status=self._c_cafe.setString(handle, valSetS) elif isinstance(valSet, (ctypes.c_char)): #print("is ctypes.c_char") #print(valSet.value) #print(valSet.value.decode()) valSetS=valSet.value.decode() with nogil: status=self._c_cafe.setString(handle, valSetS) elif isinstance(valSet, (ctypes.c_float)): valSetF=valSet.value with nogil: status=self._c_cafe.setFloat(handle, valSetF) elif isinstance(valSet, (ctypes.c_double)): valSetD=valSet.value with nogil: status=self._c_cafe.setDouble(handle, valSetD) elif isinstance(valSet, ctypesInt): #print("ctypesInt") valSetI= valSet.value with nogil: status=self._c_cafe.setLong(handle, valSetI) elif isinstance(valSet, ctypesLongLong): #print("ctypesLongLong") valSetLL=valSet.value with nogil: status=self._c_cafe.setLong(handle, valSetLL) elif isinstance(valSet, ctypesShort): #print("ctypesShort") valSetShort=valSet.value with nogil: status=self._c_cafe.setShort(handle, valSetShort) elif isinstance(valSet, ctypesUShort): #print("ctypesUShort") valSetUShort=valSet.value with nogil: status=self._c_cafe.setUShort(handle, valSetUShort) elif isinstance(valSet, (ctypesString) ): #print("ctypesString") valSetS=valSet.value with nogil: status=self._c_cafe.setString(handle, valSetS) elif isinstance(valSet, ctypesUChar): #print("ctypesUChar") valSetUChar=valSet.value with nogil: status=self._c_cafe.setChar(handle, valSetUChar) elif isinstance(valSet, (float)): #print("float type") valSetD= valSet with nogil: status=self._c_cafe.setDouble(handle, valSetD) elif isinstance(valSet, (int, long)): #print("int/long type") valSetI= valSet with nogil: status=self._c_cafe.setLong(handle, valSetI) elif isinstance(valSet, (str)): # print("str type") valSetS=valSet with nogil: status=self._c_cafe.setString(handle, valSetS) elif isinstance(valSet, (bytes,bytearray)): #print("bytes,bytearray") valSetS=valSet.decode('utf8') with nogil: status=self._c_cafe.setString(handle, valSetS) elif isinstance(valSet, (unicode)): #print("unicode") valSetS=valSet with nogil: status=self._c_cafe.setString(handle, valSetS) else: print("PyCafe def set WARNING: DATA TYPE NOT SUPPORTED") print("Input data (whether within a 'list','array.array','cython.view.memoryview','memoryview' \n\ or not) should be of , or ") type(valSet) if status !=ICAFE_NORMAL: if PYCAFE_PRINT_LEVEL>=PYCAFE_PRINT_LOW: if handle == 0: self._c_cafe.printStatusMessage(status) else: self._c_cafe.printStatus(handle, status) if self.haveExceptions: _cyCafeException = CyCafeException(_type='cafe',_source=_METHOD_,_handle=handle, _pv=self._c_cafe.getPVFromHandle(handle), \ _ec=status, _et=self.cs.code(status), _ei=self.cs.info(status)) raise Exception(_cyCafeException) return status ################################################################################## #END def set(self, handlePV, valSet): ################################################################################## ################################################################################## def setScalarList(self, handleList, list valList): cdef str _METHOD_="setScalarList(handleList, list valList)" if not isinstance(handleList, (list)): raise Exception ("EXCEPTION RAISED IN PyCafe def setScalarList. \n\ First input argument, should be of handles or PVs") if isinstance(handleList[0], (str)): handleList=self.checkForHandleList(handleList) elif not isinstance(handleList[0], (int, long)): raise Exception ("EXCEPTION RAISED IN PyCafe def setScalarList. \n\ First input argument, should be a 'list' of if handles or if PVs") if len(handleList) != len(valList): raise Exception ("EXCEPTION RAISED IN PyCafe def setScalarList. \ Length of handle list ", len(handleList), " does not match the length of data list ", len(valList)) nelemPrevious = [] #Better with PVDataHolder cdef unsigned int nelemTotal=0 for i in range(0, len(handleList)): #nelemTotal+=self.hh.getNelemNative(handleList[i]) nelemPrevious.append(self.hh.getNelemClient(handleList[i])) #cdef int size_cdu = sizeof(CAFE_DATATYPE_UNION) #do this to avoid compiler warning messages cdef vector[unsigned int] v for i in range(0, len(handleList)): v.push_back(handleList[i]) #Create temporary group from handleList #Does group exist? cdef PVDataHolder * pvd = self._c_cafe.getPVData(v) #cdef PVDataHolder * pvd = malloc( 100000000 + \ # len(handleList) * sizeof(PVDataHolder) + nelemTotal*size_cdu) for i in range(0, len(handleList)): #pvd[i].val =malloc(sizeof(CAFE_DATATYPE_UNION)) #pvd[i]= PVDataHolder(1); pvd[i].setNelem(1) cdef unsigned short valType=CAFE_STRING for i in range(0, len(handleList)): if isinstance(valList[i],(str)): pvd[i].setString(valList[i]) elif isinstance(valList[i],(float)): pvd[i].setDouble(valList[i]) elif isinstance(valList[i],(long, int)): pvd[i].setInt(valList[i]) else: print ("This line in PyCafe def setScalarList should never appear!") cdef int status=ICAFE_NORMAL with nogil: status=self._c_cafe.setPVArray(v, pvd) for i in range(0, len(handleList)): if (nelemPrevious[i] != 1): self._c_cafe.setNelemToPrevious(handleList[i],nelemPrevious[i]) #return status for individual channels statusList=[] if status !=ICAFE_NORMAL: if PYCAFE_PRINT_LEVEL>=PYCAFE_PRINT_LOW: self._c_cafe.printStatusMessage(status) for i in range(0, len(handleList)): if (pvd[i].getStatus() != ICAFE_NORMAL): print ("Handle=", handleList[i], "PV=", self.hh.getPVFromHandle(handleList[i]) ) print ("with error status=", pvd[i].getStatus()) self._c_cafe.printStatusMessage(pvd[i].getStatus()) print ("") statusList.append(pvd[i].getStatus()) #free(pvd) return status, statusList ################################################################################## ################################################################################## def setCompoundList(self, handleList, list vectorList): cdef str _METHOD_="setCompoundList(handleList, list vectorList)" if isinstance(handleList, (str)): handleList=self.getHandlesFromWithinGroup(handleList) else: if not isinstance(handleList, (list)): raise Exception ("EXCEPTION RAISED IN PyCafe def setCompoundList. \n\ First input argument, should be of handles or PVs") if isinstance(handleList[0], (str)): handleList=self.checkForHandleList(handleList) elif not isinstance(handleList[0], (int, long)): raise Exception ("EXCEPTION RAISED IN PyCafe def setCompoundList. \n\ First input argument, should be a 'list' of if handles or if PVs") if len(handleList) != len(vectorList): raise Exception ("EXCEPTION RAISED IN PyCafe def setCompoundList. \ Length of handle list ", len(handleList), " does not match the length of data list ", len(vectorList)) #do this to avoid compiler warning messages cdef vector[unsigned int] v cdef int i for i in range(0, len(handleList)): v.push_back(handleList[i]) #Create temporary group from handleList #Does group exist? cdef PVDataHolder * pvdata = self._c_cafe.getPVData(v) for i in range(0, len(vectorList)): #if not list if isinstance(vectorList[i],(str)): pvdata[i].setString(vectorList[i]) elif isinstance(vectorList[i],(float)): pvdata[i].setDouble(vectorList[i]) elif isinstance(vectorList[i],(long, int)): pvdata[i].setInt(vectorList[i]) elif isinstance(vectorList[i], (list)): #if list valType=CAFE_INVALID_DATATYPE pvdata[i].setNelem(len(vectorList[i])) #for k in range(0, len(vectorList[i])): #Just check on first element for k in range(0,1): # can expand this to all elemnts or reduce to 1 if isinstance(vectorList[i][k],(str)): valType=CAFE_STRING break elif isinstance(vectorList[i][k],(float)): valType=CAFE_DOUBLE elif isinstance(vectorList[i][k],(long, int)): if valType != CAFE_DOUBLE: valType=CAFE_LONG else: valType=CAFE_STRING break #check dt of first element if valType==CAFE_DOUBLE: pvdata[i].setVDouble(vectorList[i]) elif valType==CAFE_LONG: pvdata[i].setVInt (vectorList[i]) elif valType==CAFE_STRING: pvdata[i].setVString(vectorList[i]) else: print ("This line in PyCafe def setCompoundList should never appear!") raise Exception ("EXCEPTION RAISED IN PyCafe def setCompoundList. \n\ Unknown data input; should be one of , , , ") #endForLoop cdef int status=ICAFE_NORMAL with nogil: status=self._c_cafe.setPVArray(v, pvdata) #return status for individual channels statusList=[] if status !=ICAFE_NORMAL: if PYCAFE_PRINT_LEVEL>=PYCAFE_PRINT_LOW: self._c_cafe.printStatusMessage(status) for i in range(0, len(handleList)): if (pvdata[i].getStatus() != ICAFE_NORMAL): print ("Handle=", handleList[i], "PV=", self.hh.getPVFromHandle(handleList[i]) ) print ("with error status=", pvdata[i].getStatus()) self._c_cafe.printStatusMessage(pvdata[i].getStatus()) print ("") #raise Exception("EXCEPTION RAISED in PyCafe def setCompoundList. Status = %d" %status) statusList.append(pvdata[i].getStatus()) return status, statusList ################################################################################## ################################################################################## def setGroup(self, ghandleName, list vectorList): cdef str _METHOD_="setGroup(self, ghandleName, list vectorList)" cdef unsigned int ghandle=0 if isinstance(ghandleName, (int,long)) == 1: ghandle=ghandleName elif isinstance(ghandleName, (str)) == 1: ghandle=self.checkForGroupHandle(ghandleName) else: _cyCafeException = CyCafeException(_type='cafe',_source=_METHOD_, \ _ei="First input argument should be if group handle, else if group name") raise Exception(_cyCafeException) cdef PVGroup pvg with nogil: self._c_cafe.groupAttach(ghandle, pvg) ### #print ("len V", len(vectorList), " npv=", pvg.getNPV()) cdef PVDataHolder * pvdata = pvg.getPVData(); for i in range(0, len(vectorList)): #if not list if isinstance(vectorList[i],(str)): pvdata[i].setString(vectorList[i]) elif isinstance(vectorList[i],(float)): pvdata[i].setDouble(vectorList[i]) elif isinstance(vectorList[i],(long, int)): pvdata[i].setInt(vectorList[i]) elif isinstance(vectorList[i], (list)): #if list valType=CAFE_INVALID_DATATYPE pvdata[i].setNelem(len(vectorList[i])) #for k in range(0, len(vectorList[i])): #Just check on first element for k in range(0,1): # can expand this to all elemnts or reduce to 1 if isinstance(vectorList[i][k],(str)): valType=CAFE_STRING break elif isinstance(vectorList[i][k],(float)): valType=CAFE_DOUBLE elif isinstance(vectorList[i][k],(long, int)): if valType != CAFE_DOUBLE: valType=CAFE_LONG else: valType=CAFE_STRING break #check dt of first element if valType==CAFE_DOUBLE: pvdata[i].setVDouble(vectorList[i]) elif valType==CAFE_LONG: pvdata[i].setVInt (vectorList[i]) elif valType==CAFE_STRING: pvdata[i].setVString(vectorList[i]) else: print ("PyCafe def setGroup: Unusual data type for element", i, " : ", type(vectorList[i])) raise Exception ("EXCEPTION RAISED IN PyCafe def setGroup. \n\ Unknown data input; should be one of , , , ") #endForLoop cdef int status=ICAFE_NORMAL statusList=[] pvg.setPVData(pvdata) with nogil: status=self._c_cafe.groupSet(ghandle, pvg) cdef PVDataHolder * pvd if status !=ICAFE_NORMAL: if PYCAFE_PRINT_LEVEL>=PYCAFE_PRINT_LOW: self._c_cafe.printStatusMessage(status) #do not raise exception #raise Exception("EXCEPTION RAISED in PyCafe def setGroup. Status = %d" %status) pvd=pvg.getPVData() for i in range(0, pvg.getNPV()): statusList.append(pvd[i].getStatus()) else: statusList.append(status) return status, statusList ################################################################################## #END: def setGroup(self, ghandleName, dt='native') ################################################################################## ################################################################################## def gameSetAndMatch(self, list handlePVSet, list valSet, handlePVAction, valAction, list handlePVMatch, double tolerance, double timeout, bint printFlag): cdef str _METHOD_="setAndMatchMany(list handlePVSet, list valSet, list handlePVMatch, double tolerance, double timeout, bint printFlag)" if not isinstance(handlePVSet, (list)): raise Exception ("EXCEPTION RAISED IN PyCafe def setAndMatchMany. \n\ First input argument, should be of handles or PVs") if not isinstance(valSet, (list)): raise Exception ("EXCEPTION RAISED IN PyCafe def setAndMatchMany. \n\ Second input argument, should be of scalar values") if not isinstance(handlePVMatch, (list)): raise Exception ("EXCEPTION RAISED IN PyCafe def setAndMatchMany. \n\ Third input argument, should be of handles or PVs") if (len(handlePVSet) != len(valSet)): raise Exception ("EXCEPTION RAISED IN PyCafe def setAndMatchMany. \n\ Lengths of first (handlePVSet) and second (valSet) input lists must match!") if (len(handlePVSet) != len(handlePVMatch)): raise Exception ("EXCEPTION RAISED IN PyCafe def setAndMatchMany. \n\ Lengths of first (handlePVSet) and third (handlePVMatch) input lists must match!") if not isinstance(handlePVAction, (list)): tmp = handlePVAction handlePVAction = [] handlePVAction.append(tmp) if not isinstance(valAction, (list)): tmp = valAction valAction = [] valAction.append(tmp) cdef vector[unsigned int] handleSet handleSet.reserve(len(handlePVSet)) cdef vector[unsigned int] handleMatch handleMatch.reserve(len(handlePVMatch)) cdef vector[double] valSetV valSetV.reserve(len(valSet)) cdef vector[unsigned int] handleAction handleAction.reserve(len(handlePVAction)) cdef vector[string] valActionV valActionV.reserve(len(valAction)) for i in range(0, len(handlePVSet)): if isinstance(handlePVSet[i], (int,long)) == 1: handleSet.push_back(handlePVSet[i]) elif isinstance(handlePVSet[i], (str)) == 1: handleSet.push_back(self.checkForHandle(handlePVSet)) else: _cyCafeException = CyCafeException(_type='cafe',_source=_METHOD_, \ _ei="ThandlePVSet list member should be if handle, else if PV") raise Exception(_cyCafeException) for i in range(0, len(handlePVMatch)): if isinstance(handlePVMatch[i], (int,long)) == 1: handleMatch.push_back(handlePVMatch[i]) elif isinstance(handlePVMatch[i], (str)) == 1: handleMatch.push_back(self.checkForHandle(handlePVMatch)) else: _cyCafeException = CyCafeException(_type='cafe',_source=_METHOD_, \ _ei="handleMatch list member should be if handle, else if PV") raise Exception(_cyCafeException) for i in range(0, len(handlePVAction)): if isinstance(handlePVAction[i], (int,long)) == 1: handleAction.push_back(handlePVAction[i]) elif isinstance(handlePVAction[i], (str)) == 1: handleAction.push_back(self.checkForHandle(handlePVAction)) else: _cyCafeException = CyCafeException(_type='cafe',_source=_METHOD_, \ _ei="handlePVAction list member should be if handle, else if PV") raise Exception(_cyCafeException) for i in range(0, len(valAction)): if not isinstance(valAction[i], (str)): valActionV.push_back(str(valAction[i])) else: valActionV.push_back(valAction[i]) for i in range(0, len(valSet)): valSetV.push_back(valSet[i]) cdef int status with nogil: status=self._c_cafe.gameSetAndMatch(handleSet, valSetV, handleAction, valActionV, handleMatch, tolerance, timeout, printFlag) if status !=ICAFE_NORMAL: if PYCAFE_PRINT_LEVEL>=PYCAFE_PRINT_LOW: self._c_cafe.printStatusMessage(status) raise Exception("EXCEPTION RAISED in PyCafe def gameSetAndMatch. Status = %d" %status) return status ################################################################################## ################################################################################## def setAndMatchMany(self, list handlePVSet, list valSet, list handlePVMatch, double tolerance, double timeout, bint printFlag): cdef str _METHOD_="setAndMatchMany(list handlePVSet, list valSet, list handlePVMatch, double tolerance, double timeout, bint printFlag)" if not isinstance(handlePVSet, (list)): raise Exception ("EXCEPTION RAISED IN PyCafe def setAndMatchMany. \n\ First input argument, should be of handles or PVs") if not isinstance(valSet, (list)): raise Exception ("EXCEPTION RAISED IN PyCafe def setAndMatchMany. \n\ Second input argument, should be of scalar values") if not isinstance(handlePVMatch, (list)): raise Exception ("EXCEPTION RAISED IN PyCafe def setAndMatchMany. \n\ Third input argument, should be of handles or PVs") if (len(handlePVSet) != len(valSet)): raise Exception ("EXCEPTION RAISED IN PyCafe def setAndMatchMany. \n\ Lengths of first (handlePVSet) and second (valSet) input lists must match!") if (len(handlePVSet) != len(handlePVMatch)): raise Exception ("EXCEPTION RAISED IN PyCafe def setAndMatchMany. \n\ Lengths of first (handlePVSet) and third (handlePVMatch) input lists must match!") cdef vector[unsigned int] handleSet handleSet.reserve(len(handlePVSet)) cdef vector[unsigned int] handleMatch handleMatch.reserve(len(handlePVMatch)) cdef vector[double] valSetV valSetV.reserve(len(valSet)) for i in range(0, len(handlePVSet)): if isinstance(handlePVSet[i], (int,long)) == 1: handleSet.push_back(handlePVSet[i]) elif isinstance(handlePVSet[i], (str)) == 1: handleSet.push_back(self.checkForHandle(handlePVSet)) else: _cyCafeException = CyCafeException(_type='cafe',_source=_METHOD_, \ _ei="ThandlePVSet list member should be if handle, else if PV") raise Exception(_cyCafeException) for i in range(0, len(handlePVMatch)): if isinstance(handlePVMatch[i], (int,long)) == 1: handleMatch.push_back(handlePVMatch[i]) elif isinstance(handlePVMatch[i], (str)) == 1: handleMatch.push_back(self.checkForHandle(handlePVMatch)) else: _cyCafeException = CyCafeException(_type='cafe',_source=_METHOD_, \ _ei="handleMatch list member should be if handle, else if PV") raise Exception(_cyCafeException) for i in range(0, len(valSet)): valSetV.push_back(valSet[i]) cdef int status with nogil: status=self._c_cafe.setAndMatchMany(handleSet, valSetV, handleMatch, tolerance, timeout, printFlag) if status !=ICAFE_NORMAL: if PYCAFE_PRINT_LEVEL>=PYCAFE_PRINT_LOW: self._c_cafe.printStatusMessage(status) raise Exception("EXCEPTION RAISED in PyCafe def setAndMatchMany. Status = %d" %status) return status ################################################################################## ################################################################################## def setAndMatch(self, handlePVSet, double valSet, handlePVMatch, double tolerance, double timeout, bint printFlag): cdef str _METHOD_="setAndMatch(handlePVSet, double valSet, handlePVMatch, double tolerance, double timeout, bint printFlag)" cdef unsigned int handleSet=0 if isinstance(handlePVSet, (int,long)) == 1: handleSet=handlePVSet elif isinstance(handlePVSet, (str)) == 1: handleSet=self.checkForHandle(handlePVSet) else: _cyCafeException = CyCafeException(_type='cafe',_source=_METHOD_, \ _ei="First input argument, should be if handle, else if PV") raise Exception(_cyCafeException) cdef unsigned int handleMatch=0 if isinstance(handlePVMatch, (int,long)) == 1: handleMatch=handlePVMatch elif isinstance(handlePVMatch, (str)) == 1: handleMatch=self.checkForHandle(handlePVMatch) else: _cyCafeException = CyCafeException(_type='cafe',_source=_METHOD_, \ _ei="Third input argument, should be if handle, else if PV") raise Exception(_cyCafeException) cdef int status with nogil: status=self._c_cafe.setAndMatch(handleSet, valSet, handleMatch, tolerance, timeout, printFlag) if status !=ICAFE_NORMAL: if PYCAFE_PRINT_LEVEL>=PYCAFE_PRINT_LOW: self._c_cafe.printStatusMessage(status) raise Exception("EXCEPTION RAISED in PyCafe def setAndMatch. Status = %d" %status) return status ################################################################################## ################################################################################## def matchMany(self, list valSet, list handlePVMatch, double tolerance, double timeout, bint printFlag): cdef str _METHOD_="matchMany(self, list valSet, list handlePVMatch, double tolerance, double timeout, bint printFlag)" if not isinstance(valSet, (list)): raise Exception ("EXCEPTION RAISED IN PyCafe def matchMany. \n\ Second input argument, should be of scalar values") if not isinstance(handlePVMatch, (list)): raise Exception ("EXCEPTION RAISED IN PyCafe def matchMany. \n\ Third input argument, should be of handles or PVs") if (len(valSet) != len(handlePVMatch)): raise Exception ("EXCEPTION RAISED IN PyCafe def matchMany. \n\ Lengths of first (handlePVSet) and third (handlePVMatch) input lists must match!") cdef vector[unsigned int] handleMatch handleMatch.reserve(len(handlePVMatch)) cdef vector[double] valSetV valSetV.reserve(len(valSet)) for i in range(0, len(handlePVMatch)): if isinstance(handlePVMatch[i], (int,long)) == 1: handleMatch.push_back(handlePVMatch[i]) elif isinstance(handlePVMatch[i], (str)) == 1: handleMatch.push_back(self.checkForHandle(handlePVMatch)) else: _cyCafeException = CyCafeException(_type='cafe',_source=_METHOD_, \ _ei="First input argument, should be if handle, else if PV") raise Exception(_cyCafeException) for i in range(0, len(valSet)): valSetV.push_back(valSet[i]) cdef int status with nogil: status=self._c_cafe.matchMany( valSetV, handleMatch, tolerance, timeout, printFlag) if status !=ICAFE_NORMAL: if PYCAFE_PRINT_LEVEL>=PYCAFE_PRINT_LOW: self._c_cafe.printStatusMessage(status) raise Exception("EXCEPTION RAISED in PyCafe def matchMany. Status = %d" %status) return status ################################################################################## ################################################################################## def match(self, double valSet, handlePVMatch, double tolerance, double timeout, bint printFlag): cdef str _METHOD_="match(double valSet, handlePVMatch, double tolerance, double timeout, bint printFlag)" cdef unsigned int handleMatch=0 if isinstance(handlePVMatch, (int,long)) == 1: handleMatch=handlePVMatch elif isinstance(handlePVMatch, (str)) == 1: handleMatch=self.checkForHandle(handlePVMatch) else: _cyCafeException = CyCafeException(_type='cafe',_source=_METHOD_, \ _ei="First input argument, should be if handle, else if PV") raise Exception(_cyCafeException) cdef int status with nogil: status=self._c_cafe.match(valSet, handleMatch, tolerance, timeout, printFlag) if status !=ICAFE_NORMAL: if PYCAFE_PRINT_LEVEL>=PYCAFE_PRINT_LOW: self._c_cafe.printStatusMessage(status) raise Exception("EXCEPTION RAISED in PyCafe def match. Status = %d" %status) return status ################################################################################## ################################################################################## def setNelemCtrl(self, handlePV, unsigned int nelem): cdef str _METHOD_="setNelemCtrl(self, handlePV, unsigned int nelem)" cdef unsigned int handle=0 if isinstance(handlePV, (int,long)): handle=handlePV elif isinstance(handlePV, (str)): handle=self.checkForHandle(handlePV) else: _cyCafeException = CyCafeException(_type='cafe',_source=_METHOD_, \ _ei="First input argument, should be if handle, else if PV") raise Exception(_cyCafeException) if handle == 0: if PYCAFE_PRINT_LEVEL>=PYCAFE_PRINT_LOW: self._c_cafe.printStatusMessage(ECAFE_INVALID_HANDLE) raise Exception("EXCEPTION RAISED in PyCafe def setNelemToRetrieveFromCacheToOne") #returns nelem return self.hh.setNelemCtrl(handle, nelem) ################################################################################## def setNelem(self, handlePV, unsigned int nelem): cdef str _METHOD_="setNelem(self, handlePV, unsigned int nelem)" cdef unsigned int handle=0 if isinstance(handlePV, (int,long)): handle=handlePV elif isinstance(handlePV, (str)): handle=self.checkForHandle(handlePV) else: _cyCafeException = CyCafeException(_type='cafe',_source=_METHOD_, \ _ei="First input argument, should be if handle, else if PV") raise Exception(_cyCafeException) if handle == 0: if PYCAFE_PRINT_LEVEL>=PYCAFE_PRINT_LOW: self._c_cafe.printStatusMessage(ECAFE_INVALID_HANDLE) raise Exception("EXCEPTION RAISED in PyCafe def setNelemToRetrieveFromCacheToOne") #returns nelem return self.hh.setNelem(handle, nelem) ################################################################################## def setNelemToNative(self, handlePV): cdef str _METHOD_="setNelemToNative(self, handlePV)" cdef unsigned int handle=0 if isinstance(handlePV, (int,long)): handle=handlePV elif isinstance(handlePV, (str)): handle=self.checkForHandle(handlePV) else: _cyCafeException = CyCafeException(_type='cafe',_source=_METHOD_, \ _ei="First input argument, should be if handle, else if PV") raise Exception(_cyCafeException) if handle == 0: if PYCAFE_PRINT_LEVEL>=PYCAFE_PRINT_LOW: self._c_cafe.printStatusMessage(ECAFE_INVALID_HANDLE) raise Exception("EXCEPTION RAISED in PyCafe def setNelemToRetrieveFromCacheToOne") #returns nelem return self.hh.setNelemToNative(handle) ################################################################################## def setNelemToRetrieveFromCacheToOne(self, handlePV): cdef str _METHOD_="setNelemToRetrieveFromCacheToOne(self, handlePV)" cdef unsigned int handle=0 if isinstance(handlePV, (int,long)): handle=handlePV elif isinstance(handlePV, (str)): handle=self.checkForHandle(handlePV) else: _cyCafeException = CyCafeException(_type='cafe',_source=_METHOD_, \ _ei="First input argument, should be if handle, else if PV") raise Exception(_cyCafeException) if handle == 0: if PYCAFE_PRINT_LEVEL>=PYCAFE_PRINT_LOW: self._c_cafe.printStatusMessage(ECAFE_INVALID_HANDLE) raise Exception("EXCEPTION RAISED in PyCafe def setNelemToRetrieveFromCacheToOne") #returns previous nelem return self._c_cafe.setNelemToRetrieveFromCacheToOne(handle) ################################################################################## def setNelemToRetrieveFromCache(self, handlePV, netrfc): cdef unsigned int handle=0 if isinstance(handlePV, (int,long)): handle=handlePV elif isinstance(handlePV, (str)): handle=self.checkForHandle(handlePV) else: raise Exception ("EXCEPTION RAISED IN PyCafe def set. \n\ First input argument, should be if handle, else if PV") if handle == 0: if PYCAFE_PRINT_LEVEL>=PYCAFE_PRINT_LOW: self._c_cafe.printStatusMessage(ECAFE_INVALID_HANDLE) raise Exception("EXCEPTION RAISED in PyCafe def setNelemToRetrieveFromCacheToOne") #returns new nelem return self._c_cafe.setNelemToRetrieveFromCacheToPrevious(handle, netrfc) ################################################################################## def terminate(self): with nogil: self._c_cafe.terminate() return ################################################################################## ################################################################################### ################################################################################## #END: cdef CAFE################################################################### ##################################################################################